00106cf0 : #include static void CPU_usage_Per_thread_handler( Thread_Control *the_thread ) { 106cf0: 55 push %ebp <== NOT EXECUTED 106cf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106cf3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 106cf6: c7 80 84 00 00 00 00 movl $0x0,0x84(%eax) <== NOT EXECUTED 106cfd: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 106d00: c7 80 88 00 00 00 00 movl $0x0,0x88(%eax) <== NOT EXECUTED 106d07: 00 00 00 <== NOT EXECUTED #else the_thread->cpu_time_used = 0; #endif } 106d0a: c9 leave <== NOT EXECUTED 106d0b: c3 ret <== NOT EXECUTED 0010c168 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10c168: 55 push %ebp <== NOT EXECUTED 10c169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c16b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; 10c16e: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10c171: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED switch( node->type ) { 10c174: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10c176: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10c179: 48 dec %eax <== NOT EXECUTED 10c17a: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10c17d: 77 24 ja 10c1a3 <== NOT EXECUTED 10c17f: ff 24 85 dc 6a 11 00 jmp *0x116adc(,%eax,4) <== NOT EXECUTED case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10c186: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10c189: eb 15 jmp 10c1a0 <== NOT EXECUTED break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10c18b: c7 41 04 70 6b 11 00 movl $0x116b70,0x4(%ecx) <== NOT EXECUTED 10c192: eb 0f jmp 10c1a3 <== NOT EXECUTED break; case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10c194: c7 41 04 a8 6b 11 00 movl $0x116ba8,0x4(%ecx) <== NOT EXECUTED 10c19b: eb 06 jmp 10c1a3 <== NOT EXECUTED break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10c19d: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10c1a0: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED break; } return 0; } 10c1a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c1a5: c9 leave <== NOT EXECUTED 10c1a6: c3 ret <== NOT EXECUTED 0011dfb4 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 11dfb4: 55 push %ebp <== NOT EXECUTED 11dfb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11dfb7: 53 push %ebx <== NOT EXECUTED 11dfb8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 11dfbb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11dfbe: 8b 18 mov (%eax),%ebx <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 11dfc0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11dfc3: 66 89 43 3c mov %ax,0x3c(%ebx) <== NOT EXECUTED jnode->st_gid = group; 11dfc7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11dfca: 66 89 43 3e mov %ax,0x3e(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 11dfce: 6a 00 push $0x0 <== NOT EXECUTED 11dfd0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11dfd3: 50 push %eax <== NOT EXECUTED 11dfd4: e8 bb c0 fe ff call 10a094 <== NOT EXECUTED 11dfd9: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 11dfdc: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return 0; } 11dfdf: 31 c0 xor %eax,%eax <== NOT EXECUTED 11dfe1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11dfe4: c9 leave <== NOT EXECUTED 11dfe5: c3 ret <== NOT EXECUTED 0010e028 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10e028: 55 push %ebp <== NOT EXECUTED 10e029: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e02b: 57 push %edi <== NOT EXECUTED 10e02c: 56 push %esi <== NOT EXECUTED 10e02d: 53 push %ebx <== NOT EXECUTED 10e02e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e031: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 10e034: 31 ff xor %edi,%edi <== NOT EXECUTED 10e036: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10e03a: 74 05 je 10e041 <== NOT EXECUTED parent = parent_loc->node_access; 10e03c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e03f: 8b 38 mov (%eax),%edi <== NOT EXECUTED /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 10e041: 50 push %eax <== NOT EXECUTED 10e042: 50 push %eax <== NOT EXECUTED 10e043: 6a 60 push $0x60 <== NOT EXECUTED 10e045: 6a 01 push $0x1 <== NOT EXECUTED 10e047: e8 98 eb ff ff call 10cbe4 <== NOT EXECUTED 10e04c: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !node ) 10e04e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e051: 85 c0 test %eax,%eax <== NOT EXECUTED 10e053: 0f 84 fa 00 00 00 je 10e153 <== NOT EXECUTED /* * Fill in the basic information */ node->st_nlink = 1; 10e059: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) <== NOT EXECUTED node->type = type; 10e05f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e062: 89 50 4c mov %edx,0x4c(%eax) <== NOT EXECUTED strncpy( node->name, name, IMFS_NAME_MAX ); 10e065: 50 push %eax <== NOT EXECUTED 10e066: 6a 20 push $0x20 <== NOT EXECUTED 10e068: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10e06b: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 10e06e: 50 push %eax <== NOT EXECUTED 10e06f: e8 c4 18 00 00 call 10f938 <== NOT EXECUTED /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 10e074: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10e079: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10e07c: f7 d0 not %eax <== NOT EXECUTED 10e07e: 21 c6 and %eax,%esi <== NOT EXECUTED 10e080: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); node->st_gid = getegid(); #else node->st_uid = 0; 10e083: 66 c7 43 3c 00 00 movw $0x0,0x3c(%ebx) <== NOT EXECUTED node->st_gid = 0; 10e089: 66 c7 43 3e 00 00 movw $0x0,0x3e(%ebx) <== NOT EXECUTED /* * Now set all the times. */ gettimeofday( &tv, 0 ); 10e08f: 5a pop %edx <== NOT EXECUTED 10e090: 59 pop %ecx <== NOT EXECUTED 10e091: 6a 00 push $0x0 <== NOT EXECUTED 10e093: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10e096: 50 push %eax <== NOT EXECUTED 10e097: e8 ac ec ff ff call 10cd48 <== NOT EXECUTED node->stat_atime = (time_t) tv.tv_sec; 10e09c: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e09f: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED node->stat_mtime = (time_t) tv.tv_sec; 10e0a2: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED node->stat_ctime = (time_t) tv.tv_sec; 10e0a5: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 10e0a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e0ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e0ae: 48 dec %eax <== NOT EXECUTED 10e0af: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10e0b2: 77 62 ja 10e116 <== NOT EXECUTED 10e0b4: ff 24 85 dc 6d 11 00 jmp *0x116ddc(,%eax,4) <== NOT EXECUTED 10e0bb: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10e0be: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e0c1: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10e0c8: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10e0cb: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 10e0ce: eb 5c jmp 10e12c <== 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; 10e0d0: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10e0d3: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e0d5: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e0d8: eb 52 jmp 10e12c <== NOT EXECUTED break; case IMFS_DEVICE: node->info.device.major = info->device.major; 10e0da: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10e0dd: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e0df: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED node->info.device.minor = info->device.minor; 10e0e2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e0e5: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 10e0e8: eb 42 jmp 10e12c <== NOT EXECUTED break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 10e0ea: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 10e0f1: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10e0f8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.file.indirect = 0; 10e0ff: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED node->info.file.doubly_indirect = 0; 10e106: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED node->info.file.triply_indirect = 0; 10e10d: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 10e114: eb 16 jmp 10e12c <== NOT EXECUTED break; default: assert(0); 10e116: 68 ef 60 11 00 push $0x1160ef <== NOT EXECUTED 10e11b: 68 f4 6d 11 00 push $0x116df4 <== NOT EXECUTED 10e120: 6a 74 push $0x74 <== NOT EXECUTED 10e122: 68 90 6d 11 00 push $0x116d90 <== NOT EXECUTED 10e127: e8 4c 81 ff ff call 106278 <__assert_func> <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 10e12c: 85 ff test %edi,%edi <== NOT EXECUTED 10e12e: 74 23 je 10e153 <== NOT EXECUTED 10e130: 50 push %eax <== NOT EXECUTED 10e131: 50 push %eax <== NOT EXECUTED 10e132: 53 push %ebx <== NOT EXECUTED 10e133: 8d 47 50 lea 0x50(%edi),%eax <== NOT EXECUTED 10e136: 50 push %eax <== NOT EXECUTED 10e137: e8 e4 b8 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 10e13c: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED fs_info = parent_loc->mt_entry->fs_info; 10e13f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e142: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e145: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED node->st_ino = ++fs_info->ino_count; 10e148: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e14a: 40 inc %eax <== NOT EXECUTED 10e14b: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e14d: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED 10e150: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return node; } 10e153: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e155: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e158: 5b pop %ebx <== NOT EXECUTED 10e159: 5e pop %esi <== NOT EXECUTED 10e15a: 5f pop %edi <== NOT EXECUTED 10e15b: c9 leave <== NOT EXECUTED 10e15c: c3 ret <== NOT EXECUTED 0010c2c3 : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10c2c3: 55 push %ebp <== NOT EXECUTED 10c2c4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c2c6: 57 push %edi <== NOT EXECUTED 10c2c7: 56 push %esi <== NOT EXECUTED 10c2c8: 53 push %ebx <== NOT EXECUTED 10c2c9: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED 10c2cc: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10c2cf: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10c2d1: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) <== NOT EXECUTED 10c2d8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10c2dd: e9 52 01 00 00 jmp 10c434 <== NOT EXECUTED * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); 10c2e2: 8d 7d bf lea -0x41(%ebp),%edi <== NOT EXECUTED 10c2e5: 52 push %edx <== NOT EXECUTED 10c2e6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c2e9: 50 push %eax <== NOT EXECUTED 10c2ea: 57 push %edi <== NOT EXECUTED 10c2eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c2ee: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c2f1: 50 push %eax <== NOT EXECUTED 10c2f2: e8 c5 04 00 00 call 10c7bc <== NOT EXECUTED i += len; 10c2f7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c2fa: 89 55 ac mov %edx,-0x54(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10c2fd: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c2ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c302: 85 d2 test %edx,%edx <== NOT EXECUTED 10c304: 0f 84 06 01 00 00 je 10c410 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10c30a: 85 c0 test %eax,%eax <== NOT EXECUTED 10c30c: 74 10 je 10c31e <== NOT EXECUTED if ( node->type == IMFS_DIRECTORY ) 10c30e: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c312: 75 0a jne 10c31e <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c314: f6 42 30 40 testb $0x40,0x30(%edx) <== NOT EXECUTED 10c318: 0f 84 88 01 00 00 je 10c4a6 <== NOT EXECUTED */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10c31e: 8b 4d ac mov -0x54(%ebp),%ecx <== NOT EXECUTED 10c321: 01 4d b0 add %ecx,-0x50(%ebp) <== NOT EXECUTED if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10c324: 89 d6 mov %edx,%esi <== NOT EXECUTED switch( type ) { 10c326: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c329: 74 52 je 10c37d <== NOT EXECUTED 10c32b: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c32e: 0f 84 f3 00 00 00 je 10c427 <== NOT EXECUTED 10c334: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c337: 0f 85 f7 00 00 00 jne 10c434 <== NOT EXECUTED case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10c33d: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10c342: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c345: 74 9e je 10c2e5 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10c347: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10c34a: 3b 50 18 cmp 0x18(%eax),%edx <== NOT EXECUTED 10c34d: 75 26 jne 10c375 <== 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; 10c34f: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c352: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10c355: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c35a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c35c: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c35f: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c361: 89 df mov %ebx,%edi <== NOT EXECUTED 10c363: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); 10c365: 50 push %eax <== NOT EXECUTED 10c366: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10c369: 53 push %ebx <== NOT EXECUTED 10c36a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c36d: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED 10c370: e9 fa 00 00 00 jmp 10c46f <== NOT EXECUTED } } else { if ( !node->Parent ) 10c375: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED 10c378: e9 8f 00 00 00 jmp 10c40c <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10c37d: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10c380: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c383: 75 15 jne 10c39a <== NOT EXECUTED IMFS_evaluate_hard_link( pathloc, 0 ); 10c385: 50 push %eax <== NOT EXECUTED 10c386: 50 push %eax <== NOT EXECUTED 10c387: 6a 00 push $0x0 <== NOT EXECUTED 10c389: 53 push %ebx <== NOT EXECUTED 10c38a: e8 35 fe ff ff call 10c1c4 <== NOT EXECUTED node = pathloc->node_access; 10c38f: 8b 33 mov (%ebx),%esi <== NOT EXECUTED if ( !node ) 10c391: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c394: 85 f6 test %esi,%esi <== NOT EXECUTED 10c396: 75 23 jne 10c3bb <== NOT EXECUTED 10c398: eb 27 jmp 10c3c1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10c39a: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c39d: 75 1c jne 10c3bb <== NOT EXECUTED result = IMFS_evaluate_sym_link( pathloc, 0 ); 10c39f: 50 push %eax <== NOT EXECUTED 10c3a0: 50 push %eax <== NOT EXECUTED 10c3a1: 6a 00 push $0x0 <== NOT EXECUTED 10c3a3: 53 push %ebx <== NOT EXECUTED 10c3a4: e8 6e fe ff ff call 10c217 <== NOT EXECUTED 10c3a9: 89 c1 mov %eax,%ecx <== NOT EXECUTED node = pathloc->node_access; 10c3ab: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( result == -1 ) 10c3ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c3b0: 83 f9 ff cmp $0xffffffff,%ecx <== NOT EXECUTED 10c3b3: 0f 84 e3 00 00 00 je 10c49c <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10c3b9: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c3bb: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c3bf: 74 10 je 10c3d1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c3c1: e8 ea 22 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c3c6: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10c3cc: e9 e0 00 00 00 jmp 10c4b1 <== 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 ) { 10c3d1: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10c3d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3d6: 74 26 je 10c3fe <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10c3d8: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c3db: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10c3de: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c3e3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c3e5: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c3e8: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c3ea: 89 df mov %ebx,%edi <== NOT EXECUTED 10c3ec: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10c3ee: 50 push %eax <== NOT EXECUTED 10c3ef: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10c3f2: 53 push %ebx <== NOT EXECUTED 10c3f3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c3f6: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10c3f9: 29 4d b0 sub %ecx,-0x50(%ebp) <== NOT EXECUTED 10c3fc: eb 74 jmp 10c472 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c3fe: 50 push %eax <== NOT EXECUTED 10c3ff: 50 push %eax <== NOT EXECUTED 10c400: 57 push %edi <== NOT EXECUTED 10c401: 56 push %esi <== NOT EXECUTED 10c402: e8 29 03 00 00 call 10c730 <== NOT EXECUTED 10c407: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !node ) 10c409: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c40c: 85 f6 test %esi,%esi <== NOT EXECUTED 10c40e: 75 10 jne 10c420 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10c410: e8 9b 22 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c415: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10c41b: e9 91 00 00 00 jmp 10c4b1 <== NOT EXECUTED /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10c420: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 10c422: e9 be fe ff ff jmp 10c2e5 <== NOT EXECUTED case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c427: e8 84 22 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c42c: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10c432: eb 7d jmp 10c4b1 <== NOT EXECUTED /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10c434: 85 c0 test %eax,%eax <== NOT EXECUTED 10c436: 74 09 je 10c441 <== NOT EXECUTED 10c438: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c43b: 0f 85 a1 fe ff ff jne 10c2e2 <== NOT EXECUTED * new fs root node and let let the mounted filesystem set the handlers. * * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { 10c441: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c445: 75 3b jne 10c482 <== NOT EXECUTED if ( node->info.directory.mt_fs != NULL ) { 10c447: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10c44a: 85 c0 test %eax,%eax <== NOT EXECUTED 10c44c: 74 34 je 10c482 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10c44e: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c451: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10c454: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c459: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c45b: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c45e: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c460: 89 df mov %ebx,%edi <== NOT EXECUTED 10c462: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10c464: 50 push %eax <== NOT EXECUTED 10c465: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10c468: 53 push %ebx <== NOT EXECUTED 10c469: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c46c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c46f: 29 45 b0 sub %eax,-0x50(%ebp) <== NOT EXECUTED 10c472: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c475: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c478: 50 push %eax <== NOT EXECUTED 10c479: ff 12 call *(%edx) <== NOT EXECUTED 10c47b: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c47d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c480: eb 1a jmp 10c49c <== NOT EXECUTED } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10c482: 53 push %ebx <== NOT EXECUTED 10c483: e8 e0 fc ff ff call 10c168 <== NOT EXECUTED 10c488: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c48a: 5f pop %edi <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c48b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c48e: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10c491: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c493: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10c496: 21 c2 and %eax,%edx <== NOT EXECUTED 10c498: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c49a: 75 0a jne 10c4a6 <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10c49c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c49e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c4a1: 5b pop %ebx <== NOT EXECUTED 10c4a2: 5e pop %esi <== NOT EXECUTED 10c4a3: 5f pop %edi <== NOT EXECUTED 10c4a4: c9 leave <== NOT EXECUTED 10c4a5: c3 ret <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10c4a6: e8 05 22 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c4ab: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c4b1: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 10c4b4: eb e6 jmp 10c49c <== NOT EXECUTED 0010c53d : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10c53d: 55 push %ebp <== NOT EXECUTED 10c53e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c540: 57 push %edi <== NOT EXECUTED 10c541: 56 push %esi <== NOT EXECUTED 10c542: 53 push %ebx <== NOT EXECUTED 10c543: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10c546: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c549: 8b 30 mov (%eax),%esi <== NOT EXECUTED 10c54b: 31 db xor %ebx,%ebx <== NOT EXECUTED * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10c54d: 8d 7d bf lea -0x41(%ebp),%edi <== NOT EXECUTED 10c550: 50 push %eax <== NOT EXECUTED 10c551: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 10c554: 52 push %edx <== NOT EXECUTED 10c555: 57 push %edi <== NOT EXECUTED 10c556: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c559: 01 d8 add %ebx,%eax <== NOT EXECUTED 10c55b: 50 push %eax <== NOT EXECUTED 10c55c: e8 5b 02 00 00 call 10c7bc <== NOT EXECUTED i += len; 10c561: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10c564: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10c567: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c56a: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10c56c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c56f: 85 d2 test %edx,%edx <== NOT EXECUTED 10c571: 0f 84 5a 01 00 00 je 10c6d1 <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10c577: 85 c0 test %eax,%eax <== NOT EXECUTED 10c579: 74 10 je 10c58b <== NOT EXECUTED if ( node->type == IMFS_DIRECTORY ) 10c57b: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c57f: 75 0a jne 10c58b <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c581: f6 42 30 40 testb $0x40,0x30(%edx) <== NOT EXECUTED 10c585: 0f 84 95 01 00 00 je 10c720 <== NOT EXECUTED */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10c58b: 03 5d b0 add -0x50(%ebp),%ebx <== NOT EXECUTED if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10c58e: 89 d6 mov %edx,%esi <== NOT EXECUTED switch( type ) { 10c590: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c593: 74 1b je 10c5b0 <== NOT EXECUTED 10c595: 77 0a ja 10c5a1 <== NOT EXECUTED 10c597: 85 c0 test %eax,%eax <== NOT EXECUTED 10c599: 0f 84 f6 00 00 00 je 10c695 <== NOT EXECUTED 10c59f: eb af jmp 10c550 <== NOT EXECUTED 10c5a1: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c5a4: 74 56 je 10c5fc <== NOT EXECUTED 10c5a6: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c5a9: 75 a5 jne 10c550 <== NOT EXECUTED 10c5ab: e9 f5 00 00 00 jmp 10c6a5 <== NOT EXECUTED case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10c5b0: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10c5b5: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c5b8: 74 96 je 10c550 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10c5ba: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c5bd: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10c5c0: 3b 50 18 cmp 0x18(%eax),%edx <== NOT EXECUTED 10c5c3: 75 27 jne 10c5ec <== NOT EXECUTED if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10c5c5: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c5c8: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10c5cb: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c5d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c5d2: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c5d5: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c5d7: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c5da: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10c5dc: 50 push %eax <== NOT EXECUTED 10c5dd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c5e0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10c5e3: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c5e6: 50 push %eax <== NOT EXECUTED 10c5e7: 2b 5d b0 sub -0x50(%ebp),%ebx <== NOT EXECUTED 10c5ea: eb 7a jmp 10c666 <== NOT EXECUTED } } else { if ( !node->Parent ) 10c5ec: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED 10c5ef: 85 f6 test %esi,%esi <== NOT EXECUTED 10c5f1: 0f 85 94 00 00 00 jne 10c68b <== NOT EXECUTED 10c5f7: e9 d5 00 00 00 jmp 10c6d1 <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10c5fc: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10c5ff: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c602: 74 05 je 10c609 <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10c604: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c607: 75 1a jne 10c623 <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); 10c609: 50 push %eax <== NOT EXECUTED 10c60a: 50 push %eax <== NOT EXECUTED 10c60b: 6a 00 push $0x0 <== NOT EXECUTED 10c60d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c610: e8 a1 fe ff ff call 10c4b6 <== NOT EXECUTED 10c615: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( result == -1 ) 10c617: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c61a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c61d: 0f 84 f3 00 00 00 je 10c716 <== NOT EXECUTED return -1; } node = pathloc->node_access; 10c623: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c626: 8b 01 mov (%ecx),%eax <== NOT EXECUTED if ( !node ) 10c628: 85 c0 test %eax,%eax <== NOT EXECUTED 10c62a: 0f 84 ca 00 00 00 je 10c6fa <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c630: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10c634: 0f 85 c0 00 00 00 jne 10c6fa <== 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 ) { 10c63a: 8b 50 5c mov 0x5c(%eax),%edx <== NOT EXECUTED 10c63d: 85 d2 test %edx,%edx <== NOT EXECUTED 10c63f: 74 38 je 10c679 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10c641: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c644: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED 10c647: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c64c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c64e: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c651: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c653: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c656: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10c658: 57 push %edi <== NOT EXECUTED 10c659: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c65c: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10c65f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c662: 50 push %eax <== NOT EXECUTED 10c663: 2b 5d f0 sub -0x10(%ebp),%ebx <== NOT EXECUTED 10c666: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c669: 01 d8 add %ebx,%eax <== NOT EXECUTED 10c66b: 50 push %eax <== NOT EXECUTED 10c66c: ff 52 04 call *0x4(%edx) <== NOT EXECUTED 10c66f: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c671: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c674: e9 9d 00 00 00 jmp 10c716 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c679: 56 push %esi <== NOT EXECUTED 10c67a: 56 push %esi <== NOT EXECUTED 10c67b: 57 push %edi <== NOT EXECUTED 10c67c: 50 push %eax <== NOT EXECUTED 10c67d: e8 ae 00 00 00 call 10c730 <== NOT EXECUTED 10c682: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10c684: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c687: 85 c0 test %eax,%eax <== NOT EXECUTED 10c689: 74 27 je 10c6b2 <== NOT EXECUTED done = true; else pathloc->node_access = node; 10c68b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c68e: 89 32 mov %esi,(%edx) <== NOT EXECUTED 10c690: e9 bb fe ff ff jmp 10c550 <== NOT EXECUTED break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10c695: e8 16 20 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c69a: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10c6a0: e9 86 00 00 00 jmp 10c72b <== NOT EXECUTED break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c6a5: e8 06 20 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c6aa: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10c6b0: eb 79 jmp 10c72b <== NOT EXECUTED case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10c6b2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c6b4: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 10c6b7: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 10c6ba: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10c6bd: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10c6bf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c6c2: 01 d8 add %ebx,%eax <== NOT EXECUTED 10c6c4: eb 18 jmp 10c6de <== NOT EXECUTED /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10c6c6: 40 inc %eax <== NOT EXECUTED if ( !IMFS_is_separator( path[ i ] ) ) 10c6c7: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10c6ca: 74 12 je 10c6de <== NOT EXECUTED 10c6cc: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10c6cf: 74 0d je 10c6de <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10c6d1: e8 da 1f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c6d6: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10c6dc: eb 4d jmp 10c72b <== NOT EXECUTED /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10c6de: 8a 10 mov (%eax),%dl <== NOT EXECUTED 10c6e0: 84 d2 test %dl,%dl <== NOT EXECUTED 10c6e2: 75 e2 jne 10c6c6 <== NOT EXECUTED /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10c6e4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c6e7: e8 7c fa ff ff call 10c168 <== NOT EXECUTED 10c6ec: 89 c2 mov %eax,%edx <== NOT EXECUTED /* * The returned node must be a directory */ node = pathloc->node_access; 10c6ee: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c6f1: 8b 01 mov (%ecx),%eax <== NOT EXECUTED if ( node->type != IMFS_DIRECTORY ) 10c6f3: 59 pop %ecx <== NOT EXECUTED 10c6f4: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10c6f8: 74 0d je 10c707 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c6fa: e8 b1 1f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c6ff: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10c705: eb 24 jmp 10c72b <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c707: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10c70a: 25 c0 00 00 00 and $0xc0,%eax <== NOT EXECUTED 10c70f: 3d c0 00 00 00 cmp $0xc0,%eax <== NOT EXECUTED 10c714: 75 0a jne 10c720 <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10c716: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c718: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c71b: 5b pop %ebx <== NOT EXECUTED 10c71c: 5e pop %esi <== NOT EXECUTED 10c71d: 5f pop %edi <== NOT EXECUTED 10c71e: c9 leave <== NOT EXECUTED 10c71f: c3 ret <== NOT EXECUTED */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10c720: e8 8b 1f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c725: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c72b: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10c72e: eb e6 jmp 10c716 <== NOT EXECUTED 0010c1c4 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c1c4: 55 push %ebp <== NOT EXECUTED 10c1c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1c7: 53 push %ebx <== NOT EXECUTED 10c1c8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c1cb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10c1ce: 8b 03 mov (%ebx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10c1d0: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED 10c1d4: 74 0d je 10c1e3 <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); 10c1d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c1d9: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c1de: e8 7d d5 ff ff call 109760 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10c1e3: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 10c1e6: 89 03 mov %eax,(%ebx) <== NOT EXECUTED IMFS_Set_handlers( node ); 10c1e8: 53 push %ebx <== NOT EXECUTED 10c1e9: e8 7a ff ff ff call 10c168 <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c1ee: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c1f1: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10c1f4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10c1f6: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10c1f9: 21 d0 and %edx,%eax <== NOT EXECUTED 10c1fb: 59 pop %ecx <== NOT EXECUTED 10c1fc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c1fe: 75 07 jne 10c207 <== NOT EXECUTED 10c200: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10c202: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c205: c9 leave <== NOT EXECUTED 10c206: 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 ); 10c207: e8 a4 24 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c20c: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c212: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c215: eb eb jmp 10c202 <== NOT EXECUTED 0010c4b6 : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c4b6: 55 push %ebp <== NOT EXECUTED 10c4b7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c4b9: 57 push %edi <== NOT EXECUTED 10c4ba: 56 push %esi <== NOT EXECUTED 10c4bb: 53 push %ebx <== NOT EXECUTED 10c4bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4bf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c4c2: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10c4c5: 8b 33 mov (%ebx),%esi <== NOT EXECUTED /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10c4c7: 8b 15 6c a9 11 00 mov 0x11a96c,%edx <== NOT EXECUTED 10c4cd: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10c4d0: 40 inc %eax <== NOT EXECUTED 10c4d1: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10c4d5: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED 10c4d9: 76 16 jbe 10c4f1 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 10c4db: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ELOOP ); 10c4e1: e8 ca 21 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c4e6: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED 10c4ec: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10c4ef: eb 42 jmp 10c533 <== NOT EXECUTED /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10c4f1: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c4f4: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c4f7: 75 0b jne 10c504 <== NOT EXECUTED result = IMFS_evaluate_hard_link( node, flags ); 10c4f9: 50 push %eax <== NOT EXECUTED 10c4fa: 50 push %eax <== NOT EXECUTED 10c4fb: 57 push %edi <== NOT EXECUTED 10c4fc: 53 push %ebx <== NOT EXECUTED 10c4fd: e8 c2 fc ff ff call 10c1c4 <== NOT EXECUTED 10c502: eb 0e jmp 10c512 <== NOT EXECUTED else if (jnode->type == IMFS_SYM_LINK ) 10c504: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c507: 75 12 jne 10c51b <== NOT EXECUTED result = IMFS_evaluate_sym_link( node, flags ); 10c509: 51 push %ecx <== NOT EXECUTED 10c50a: 51 push %ecx <== NOT EXECUTED 10c50b: 57 push %edi <== NOT EXECUTED 10c50c: 53 push %ebx <== NOT EXECUTED 10c50d: e8 05 fd ff ff call 10c217 <== NOT EXECUTED 10c512: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10c517: 85 c0 test %eax,%eax <== NOT EXECUTED 10c519: 75 0d jne 10c528 <== NOT EXECUTED 10c51b: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c51e: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10c521: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c524: 76 9f jbe 10c4c5 <== NOT EXECUTED 10c526: 31 d2 xor %edx,%edx <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10c528: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10c52d: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) <== NOT EXECUTED return result; } 10c533: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c535: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c538: 5b pop %ebx <== NOT EXECUTED 10c539: 5e pop %esi <== NOT EXECUTED 10c53a: 5f pop %edi <== NOT EXECUTED 10c53b: c9 leave <== NOT EXECUTED 10c53c: c3 ret <== NOT EXECUTED 0010c1a7 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10c1a7: 55 push %ebp <== NOT EXECUTED 10c1a8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1aa: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c1ad: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10c1b0: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c1b3: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10c1b5: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10c1b8: 21 c2 and %eax,%edx <== NOT EXECUTED 10c1ba: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c1bc: 0f 94 c0 sete %al <== NOT EXECUTED 10c1bf: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED return 1; return 0; } 10c1c2: c9 leave <== NOT EXECUTED 10c1c3: c3 ret <== NOT EXECUTED 0010c217 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c217: 55 push %ebp <== NOT EXECUTED 10c218: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c21a: 57 push %edi <== NOT EXECUTED 10c21b: 56 push %esi <== NOT EXECUTED 10c21c: 53 push %ebx <== NOT EXECUTED 10c21d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10c220: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c223: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10c225: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10c229: 74 0a je 10c235 <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); 10c22b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c22e: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c233: eb 0f jmp 10c244 <== NOT EXECUTED if ( !jnode->Parent ) 10c235: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10c238: 85 c0 test %eax,%eax <== NOT EXECUTED 10c23a: 75 0d jne 10c249 <== NOT EXECUTED rtems_fatal_error_occurred( 0xBAD00000 ); 10c23c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c23f: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10c244: e8 17 d5 ff ff call 109760 <== 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; 10c249: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c24c: 89 02 mov %eax,(%edx) <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 10c24e: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10c251: 8a 00 mov (%eax),%al <== NOT EXECUTED 10c253: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10c255: 74 0a je 10c261 <== NOT EXECUTED 10c257: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10c259: 74 06 je 10c261 <== NOT EXECUTED 10c25b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c25d: 84 c0 test %al,%al <== NOT EXECUTED 10c25f: 75 17 jne 10c278 <== NOT EXECUTED 10c261: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10c266: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10c269: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c26e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c271: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10c273: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10c278: 56 push %esi <== NOT EXECUTED 10c279: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c27c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c27f: 03 53 50 add 0x50(%ebx),%edx <== NOT EXECUTED 10c282: 52 push %edx <== NOT EXECUTED 10c283: e8 3b 00 00 00 call 10c2c3 <== NOT EXECUTED 10c288: 89 c3 mov %eax,%ebx <== NOT EXECUTED &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10c28a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c28d: e8 d6 fe ff ff call 10c168 <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c292: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c295: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10c298: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c29b: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10c29d: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10c2a0: 21 c2 and %eax,%edx <== NOT EXECUTED 10c2a2: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10c2a5: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c2a7: 75 0a jne 10c2b3 <== NOT EXECUTED if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10c2a9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c2ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c2ae: 5b pop %ebx <== NOT EXECUTED 10c2af: 5e pop %esi <== NOT EXECUTED 10c2b0: 5f pop %edi <== NOT EXECUTED 10c2b1: c9 leave <== NOT EXECUTED 10c2b2: 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 ); 10c2b3: e8 f8 23 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c2b8: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c2be: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10c2c1: eb e6 jmp 10c2a9 <== NOT EXECUTED 0010e160 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 10e160: 55 push %ebp <== NOT EXECUTED 10e161: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e163: 53 push %ebx <== NOT EXECUTED 10e164: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10e167: 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; 10e16a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e16d: 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 ) ) ) 10e16f: f7 c2 00 fe ff ff test $0xfffffe00,%edx <== NOT EXECUTED 10e175: 74 10 je 10e187 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 10e177: e8 34 05 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10e17c: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10e182: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10e185: eb 25 jmp 10e1ac <== NOT EXECUTED jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 10e187: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e18a: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED 10e18f: 09 c2 or %eax,%edx <== NOT EXECUTED 10e191: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 10e194: 50 push %eax <== NOT EXECUTED 10e195: 50 push %eax <== NOT EXECUTED 10e196: 6a 00 push $0x0 <== NOT EXECUTED 10e198: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10e19b: 50 push %eax <== NOT EXECUTED 10e19c: e8 a7 eb ff ff call 10cd48 <== NOT EXECUTED 10e1a1: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10e1a4: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10e1a7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e1a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10e1ac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e1af: c9 leave <== NOT EXECUTED 10e1b0: c3 ret <== NOT EXECUTED 001290bc : int IMFS_fcntl( int cmd, rtems_libio_t *iop ) { 1290bc: 55 push %ebp <== NOT EXECUTED 1290bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 1290bf: 31 c0 xor %eax,%eax <== NOT EXECUTED 1290c1: c9 leave <== NOT EXECUTED 1290c2: c3 ret <== NOT EXECUTED 001290c4 : #include "imfs.h" int IMFS_fdatasync( rtems_libio_t *iop ) { 1290c4: 55 push %ebp <== NOT EXECUTED 1290c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 1290c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 1290c9: c9 leave <== NOT EXECUTED 1290ca: c3 ret <== NOT EXECUTED 0010c730 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10c730: 55 push %ebp <== NOT EXECUTED 10c731: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c733: 57 push %edi <== NOT EXECUTED 10c734: 56 push %esi <== NOT EXECUTED 10c735: 53 push %ebx <== NOT EXECUTED 10c736: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c739: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c73c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10c73f: 85 db test %ebx,%ebx <== NOT EXECUTED 10c741: 75 16 jne 10c759 <== NOT EXECUTED 10c743: 68 f4 6a 11 00 push $0x116af4 <== NOT EXECUTED 10c748: 68 58 6b 11 00 push $0x116b58 <== NOT EXECUTED 10c74d: 6a 2a push $0x2a <== NOT EXECUTED 10c74f: 68 fe 6a 11 00 push $0x116afe <== NOT EXECUTED 10c754: e8 1f 9b ff ff call 106278 <__assert_func> <== NOT EXECUTED if ( !name ) 10c759: 85 ff test %edi,%edi <== NOT EXECUTED 10c75b: 74 52 je 10c7af <== NOT EXECUTED /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10c75d: 51 push %ecx <== NOT EXECUTED 10c75e: 51 push %ecx <== NOT EXECUTED 10c75f: 68 50 6b 11 00 push $0x116b50 <== NOT EXECUTED 10c764: 57 push %edi <== NOT EXECUTED 10c765: e8 42 30 00 00 call 10f7ac <== NOT EXECUTED 10c76a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c76d: 85 c0 test %eax,%eax <== NOT EXECUTED 10c76f: 74 40 je 10c7b1 <== NOT EXECUTED return directory; if ( !strcmp( name, dotdotname ) ) 10c771: 52 push %edx <== NOT EXECUTED 10c772: 52 push %edx <== NOT EXECUTED 10c773: 68 52 6b 11 00 push $0x116b52 <== NOT EXECUTED 10c778: 57 push %edi <== NOT EXECUTED 10c779: e8 2e 30 00 00 call 10f7ac <== NOT EXECUTED 10c77e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c781: 85 c0 test %eax,%eax <== NOT EXECUTED 10c783: 75 05 jne 10c78a <== NOT EXECUTED return directory->Parent; 10c785: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10c788: eb 27 jmp 10c7b1 <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10c78a: 8b 73 50 mov 0x50(%ebx),%esi <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10c78d: 83 c3 54 add $0x54,%ebx <== NOT EXECUTED 10c790: eb 19 jmp 10c7ab <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 10c792: 50 push %eax <== NOT EXECUTED 10c793: 50 push %eax <== NOT EXECUTED 10c794: 8d 46 0c lea 0xc(%esi),%eax <== NOT EXECUTED 10c797: 50 push %eax <== NOT EXECUTED 10c798: 57 push %edi <== NOT EXECUTED 10c799: e8 0e 30 00 00 call 10f7ac <== NOT EXECUTED 10c79e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7a1: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7a3: 75 04 jne 10c7a9 <== NOT EXECUTED 10c7a5: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10c7a7: eb 08 jmp 10c7b1 <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10c7a9: 8b 36 mov (%esi),%esi <== 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 ); 10c7ab: 39 de cmp %ebx,%esi <== NOT EXECUTED 10c7ad: 75 e3 jne 10c792 <== NOT EXECUTED 10c7af: 31 db xor %ebx,%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10c7b1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c7b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7b6: 5b pop %ebx <== NOT EXECUTED 10c7b7: 5e pop %esi <== NOT EXECUTED 10c7b8: 5f pop %edi <== NOT EXECUTED 10c7b9: c9 leave <== NOT EXECUTED 10c7ba: c3 ret <== NOT EXECUTED 0011e6e8 : */ int IMFS_freenodinfo( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 11e6e8: 55 push %ebp <== NOT EXECUTED 11e6e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11e6eb: 31 c0 xor %eax,%eax <== NOT EXECUTED 11e6ed: c9 leave <== NOT EXECUTED 11e6ee: c3 ret <== NOT EXECUTED 0011e6f0 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 11e6f0: 55 push %ebp <== NOT EXECUTED 11e6f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e6f3: 57 push %edi <== NOT EXECUTED 11e6f4: 56 push %esi <== NOT EXECUTED 11e6f5: 53 push %ebx <== NOT EXECUTED 11e6f6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11e6f9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED /* * Traverse tree that starts at the mt_fs_root and deallocate memory * associated memory space */ jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access; 11e6fc: 8b 58 18 mov 0x18(%eax),%ebx <== NOT EXECUTED loc = temp_mt_entry->mt_fs_root; 11e6ff: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 11e702: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 11e705: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11e70a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Set this to null to indicate that it is being unmounted. */ temp_mt_entry->mt_fs_root.node_access = NULL; 11e70c: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 11e713: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 11e716: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED loc.node_access = (void *)jnode; 11e719: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &loc ); 11e71c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e71f: 56 push %esi <== NOT EXECUTED 11e720: e8 fb f9 ff ff call 11e120 <== NOT EXECUTED if ( jnode->type != IMFS_DIRECTORY ) { 11e725: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e728: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 11e72c: 75 08 jne 11e736 <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 11e72e: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 11e731: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 11e734: 75 12 jne 11e748 <== NOT EXECUTED result = IMFS_unlink( &loc ); 11e736: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e739: 56 push %esi <== NOT EXECUTED 11e73a: e8 85 b3 fe ff call 109ac4 <== NOT EXECUTED if (result != 0) 11e73f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e742: 85 c0 test %eax,%eax <== NOT EXECUTED 11e744: 75 1d jne 11e763 <== NOT EXECUTED 11e746: 89 fb mov %edi,%ebx <== NOT EXECUTED return -1; jnode = next; } if ( jnode != NULL ) { 11e748: 85 db test %ebx,%ebx <== NOT EXECUTED 11e74a: 74 1c je 11e768 <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { 11e74c: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 11e750: 75 c4 jne 11e716 <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 11e752: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 11e755: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 11e758: 74 bc je 11e716 <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); 11e75a: 8b 5b 50 mov 0x50(%ebx),%ebx <== NOT EXECUTED } } } while (jnode != NULL); 11e75d: 85 db test %ebx,%ebx <== NOT EXECUTED 11e75f: 75 b5 jne 11e716 <== NOT EXECUTED 11e761: eb 05 jmp 11e768 <== NOT EXECUTED 11e763: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11e766: eb 02 jmp 11e76a <== NOT EXECUTED 11e768: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11e76a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e76d: 5b pop %ebx <== NOT EXECUTED 11e76e: 5e pop %esi <== NOT EXECUTED 11e76f: 5f pop %edi <== NOT EXECUTED 11e770: c9 leave <== NOT EXECUTED 11e771: c3 ret <== NOT EXECUTED 0010c7bc : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10c7bc: 55 push %ebp <== NOT EXECUTED 10c7bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7bf: 56 push %esi <== NOT EXECUTED 10c7c0: 53 push %ebx <== NOT EXECUTED 10c7c1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c7c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10c7c7: 8a 01 mov (%ecx),%al <== NOT EXECUTED 10c7c9: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c7cb: eb 10 jmp 10c7dd <== NOT EXECUTED while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; 10c7cd: 88 04 16 mov %al,(%esi,%edx,1) <== NOT EXECUTED if ( i == IMFS_NAME_MAX ) 10c7d0: 75 07 jne 10c7d9 <== NOT EXECUTED 10c7d2: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 10c7d7: eb 77 jmp 10c850 <== NOT EXECUTED return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10c7d9: 42 inc %edx <== NOT EXECUTED 10c7da: 8a 04 11 mov (%ecx,%edx,1),%al <== NOT EXECUTED /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10c7dd: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10c7df: 74 0d je 10c7ee <== NOT EXECUTED 10c7e1: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10c7e3: 74 09 je 10c7ee <== NOT EXECUTED 10c7e5: 84 c0 test %al,%al <== NOT EXECUTED 10c7e7: 74 05 je 10c7ee <== NOT EXECUTED 10c7e9: 83 fa 20 cmp $0x20,%edx <== NOT EXECUTED 10c7ec: 7e df jle 10c7cd <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { 10c7ee: 85 d2 test %edx,%edx <== NOT EXECUTED 10c7f0: 75 0e jne 10c800 <== NOT EXECUTED token[i] = c; 10c7f2: 88 06 mov %al,(%esi) <== NOT EXECUTED if ( token[i] != '\0' ) { 10c7f4: 31 db xor %ebx,%ebx <== NOT EXECUTED 10c7f6: 84 c0 test %al,%al <== NOT EXECUTED 10c7f8: 74 1b je 10c815 <== NOT EXECUTED 10c7fa: b2 01 mov $0x1,%dl <== NOT EXECUTED 10c7fc: b3 01 mov $0x1,%bl <== NOT EXECUTED 10c7fe: eb 15 jmp 10c815 <== NOT EXECUTED i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10c800: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED 10c805: 80 7c 16 ff 00 cmpb $0x0,-0x1(%esi,%edx,1) <== NOT EXECUTED 10c80a: 74 09 je 10c815 <== NOT EXECUTED token[i] = '\0'; 10c80c: c6 04 16 00 movb $0x0,(%esi,%edx,1) <== NOT EXECUTED 10c810: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10c815: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c818: 89 10 mov %edx,(%eax) <== NOT EXECUTED /* * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { 10c81a: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10c81d: 75 31 jne 10c850 <== NOT EXECUTED if ( strcmp( token, "..") == 0 ) 10c81f: 52 push %edx <== NOT EXECUTED 10c820: 52 push %edx <== NOT EXECUTED 10c821: 68 45 67 11 00 push $0x116745 <== NOT EXECUTED 10c826: 56 push %esi <== NOT EXECUTED 10c827: e8 80 2f 00 00 call 10f7ac <== NOT EXECUTED 10c82c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c82f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c831: 75 04 jne 10c837 <== NOT EXECUTED 10c833: b3 02 mov $0x2,%bl <== NOT EXECUTED 10c835: eb 19 jmp 10c850 <== NOT EXECUTED type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10c837: 50 push %eax <== NOT EXECUTED 10c838: 50 push %eax <== NOT EXECUTED 10c839: 68 46 67 11 00 push $0x116746 <== NOT EXECUTED 10c83e: 56 push %esi <== NOT EXECUTED 10c83f: e8 68 2f 00 00 call 10f7ac <== NOT EXECUTED 10c844: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c847: 85 c0 test %eax,%eax <== NOT EXECUTED 10c849: 75 05 jne 10c850 <== NOT EXECUTED 10c84b: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED type = IMFS_CURRENT_DIR; } return type; } 10c850: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c852: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c855: 5b pop %ebx <== NOT EXECUTED 10c856: 5e pop %esi <== NOT EXECUTED 10c857: c9 leave <== NOT EXECUTED 10c858: c3 ret <== NOT EXECUTED 001097b8 : */ int IMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 1097b8: 55 push %ebp <== NOT EXECUTED 1097b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 1097be: 68 b0 c9 13 00 push $0x13c9b0 <== NOT EXECUTED 1097c3: 68 20 ca 13 00 push $0x13ca20 <== NOT EXECUTED 1097c8: 68 a8 aa 13 00 push $0x13aaa8 <== NOT EXECUTED 1097cd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1097d0: e8 03 00 00 00 call 1097d8 <== NOT EXECUTED temp_mt_entry, &IMFS_ops, &IMFS_memfile_handlers, &IMFS_directory_handlers ); } 1097d5: c9 leave <== NOT EXECUTED 1097d6: c3 ret <== NOT EXECUTED 0010c85c : 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 ) { 10c85c: 55 push %ebp <== NOT EXECUTED 10c85d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c85f: 57 push %edi <== NOT EXECUTED 10c860: 56 push %esi <== NOT EXECUTED 10c861: 53 push %ebx <== NOT EXECUTED 10c862: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c865: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode; /* * determine/check value for imfs_memfile_bytes_per_block */ IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block, 10c868: 8b 0d dc 85 11 00 mov 0x1185dc,%ecx <== NOT EXECUTED 10c86e: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10c873: 31 d2 xor %edx,%edx <== NOT EXECUTED int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10c875: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c877: 74 0d je 10c886 <== NOT EXECUTED bit_mask <<= 1) { 10c879: d1 e0 shl %eax <== NOT EXECUTED 10c87b: 42 inc %edx <== NOT EXECUTED int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10c87c: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED 10c87f: 75 f4 jne 10c875 <== NOT EXECUTED 10c881: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { is_valid = true; } } *dest_bytes_per_block = ((is_valid) 10c886: a3 bc c7 11 00 mov %eax,0x11c7bc <== NOT EXECUTED * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_node( 10c88b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c88e: 6a 00 push $0x0 <== NOT EXECUTED 10c890: 68 ed 41 00 00 push $0x41ed <== NOT EXECUTED 10c895: 68 a1 67 11 00 push $0x1167a1 <== NOT EXECUTED 10c89a: 6a 01 push $0x1 <== NOT EXECUTED 10c89c: 6a 00 push $0x0 <== NOT EXECUTED 10c89e: e8 85 17 00 00 call 10e028 <== NOT EXECUTED 10c8a3: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10c8a6: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10c8a9: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = op_table; 10c8ac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c8af: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10c8b2: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 10c8b5: be 60 6d 11 00 mov $0x116d60,%esi <== NOT EXECUTED 10c8ba: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED 10c8bf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10c8c1: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10c8c4: 6a 0c push $0xc <== NOT EXECUTED 10c8c6: 6a 01 push $0x1 <== NOT EXECUTED 10c8c8: e8 17 03 00 00 call 10cbe4 <== NOT EXECUTED 10c8cd: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !fs_info ){ 10c8cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8d2: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8d4: 75 1e jne 10c8f4 <== NOT EXECUTED free(temp_mt_entry->mt_fs_root.node_access); 10c8d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c8d9: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10c8dc: e8 87 9b ff ff call 106468 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10c8e1: e8 ca 1d 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c8e6: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10c8ec: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c8ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8f2: eb 21 jmp 10c915 <== NOT EXECUTED } temp_mt_entry->fs_info = fs_info; 10c8f4: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10c8f7: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED fs_info->memfile_handlers = memfile_handlers; 10c8fd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c900: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED fs_info->directory_handlers = directory_handlers; 10c903: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10c906: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10c909: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10c90c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) <== NOT EXECUTED 10c913: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c915: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c918: 5b pop %ebx <== NOT EXECUTED 10c919: 5e pop %esi <== NOT EXECUTED 10c91a: 5f pop %edi <== NOT EXECUTED 10c91b: c9 leave <== NOT EXECUTED 10c91c: c3 ret <== NOT EXECUTED 0010989c : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 10989c: 55 push %ebp <== NOT EXECUTED 10989d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10989f: 53 push %ebx <== NOT EXECUTED 1098a0: 83 ec 44 sub $0x44,%esp <== NOT EXECUTED /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 1098a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1098a6: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1098a8: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 1098ab: 66 83 78 34 07 cmpw $0x7,0x34(%eax) <== NOT EXECUTED 1098b0: 76 0d jbe 1098bf <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EMLINK ); 1098b2: e8 e9 11 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 1098b7: c7 00 1f 00 00 00 movl $0x1f,(%eax) <== NOT EXECUTED 1098bd: eb 39 jmp 1098f8 <== NOT EXECUTED /* * Remove any separators at the end of the string. */ IMFS_get_token( token, new_name, &i ); 1098bf: 52 push %edx <== NOT EXECUTED 1098c0: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1098c3: 50 push %eax <== NOT EXECUTED 1098c4: 8d 5d bf lea -0x41(%ebp),%ebx <== NOT EXECUTED 1098c7: 53 push %ebx <== NOT EXECUTED 1098c8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1098cb: e8 48 fe ff ff call 109718 <== NOT EXECUTED /* * Create a new link node. */ new_node = IMFS_create_node( 1098d0: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1098d3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1098d6: 68 ff a1 00 00 push $0xa1ff <== NOT EXECUTED 1098db: 53 push %ebx <== NOT EXECUTED 1098dc: 6a 03 push $0x3 <== NOT EXECUTED 1098de: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1098e1: e8 02 47 01 00 call 11dfe8 <== NOT EXECUTED new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 1098e6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1098e9: 85 c0 test %eax,%eax <== NOT EXECUTED 1098eb: 75 10 jne 1098fd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 1098ed: e8 ae 11 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 1098f2: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1098f8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1098fb: eb 22 jmp 10991f <== NOT EXECUTED /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 1098fd: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109900: 66 ff 40 34 incw 0x34(%eax) <== NOT EXECUTED IMFS_update_ctime( info.hard_link.link_node ); 109904: 50 push %eax <== NOT EXECUTED 109905: 50 push %eax <== NOT EXECUTED 109906: 6a 00 push $0x0 <== NOT EXECUTED 109908: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10990b: 50 push %eax <== NOT EXECUTED 10990c: e8 83 07 00 00 call 10a094 <== NOT EXECUTED 109911: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109914: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109917: 89 50 48 mov %edx,0x48(%eax) <== NOT EXECUTED 10991a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10991c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10991f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109922: c9 leave <== NOT EXECUTED 109923: c3 ret <== NOT EXECUTED 00124244 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 124244: 55 push %ebp <== NOT EXECUTED 124245: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124247: 53 push %ebx <== NOT EXECUTED 124248: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 12424b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 12424e: 85 c0 test %eax,%eax <== NOT EXECUTED 124250: 75 11 jne 124263 <== NOT EXECUTED 124252: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 124257: 68 18 d3 13 00 push $0x13d318 <== NOT EXECUTED 12425c: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 124261: eb 15 jmp 124278 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 124263: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 124267: 74 19 je 124282 <== NOT EXECUTED 124269: 68 e9 d1 13 00 push $0x13d1e9 <== NOT EXECUTED 12426e: 68 18 d3 13 00 push $0x13d318 <== NOT EXECUTED 124273: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 124278: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 12427d: e8 42 5a fe ff call 109cc4 <__assert_func> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 124282: 52 push %edx <== NOT EXECUTED 124283: 6a 01 push $0x1 <== NOT EXECUTED 124285: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124288: 50 push %eax <== NOT EXECUTED 124289: e8 8c fb ff ff call 123e1a <== NOT EXECUTED 12428e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( *block_entry_ptr ) 124290: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124293: 31 c0 xor %eax,%eax <== NOT EXECUTED 124295: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 124298: 75 14 jne 1242ae <== NOT EXECUTED #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 12429a: e8 59 fb ff ff call 123df8 <== NOT EXECUTED 12429f: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !memory ) 1242a1: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 1242a6: 85 d2 test %edx,%edx <== NOT EXECUTED 1242a8: 74 04 je 1242ae <== NOT EXECUTED return 1; *block_entry_ptr = memory; 1242aa: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 1242ac: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1242ae: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1242b1: c9 leave <== NOT EXECUTED 1242b2: c3 ret <== NOT EXECUTED 001242b3 : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 1242b3: 55 push %ebp <== NOT EXECUTED 1242b4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1242b6: 57 push %edi <== NOT EXECUTED 1242b7: 56 push %esi <== NOT EXECUTED 1242b8: 53 push %ebx <== NOT EXECUTED 1242b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1242bc: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1242bf: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1242c2: 85 ff test %edi,%edi <== NOT EXECUTED 1242c4: 75 11 jne 1242d7 <== NOT EXECUTED 1242c6: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 1242cb: 68 30 d3 13 00 push $0x13d330 <== NOT EXECUTED 1242d0: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 1242d5: eb 15 jmp 1242ec <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1242d7: 83 7f 4c 05 cmpl $0x5,0x4c(%edi) <== NOT EXECUTED 1242db: 74 19 je 1242f6 <== NOT EXECUTED 1242dd: 68 e9 d1 13 00 push $0x13d1e9 <== NOT EXECUTED 1242e2: 68 30 d3 13 00 push $0x13d330 <== NOT EXECUTED 1242e7: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 1242ec: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 1242f1: e8 ce 59 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 1242f6: 8b 0d 98 69 14 00 mov 0x146998,%ecx <== NOT EXECUTED 1242fc: 89 ca mov %ecx,%edx <== NOT EXECUTED 1242fe: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 124301: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 124304: 0f af c2 imul %edx,%eax <== NOT EXECUTED 124307: 40 inc %eax <== NOT EXECUTED 124308: 0f af c2 imul %edx,%eax <== NOT EXECUTED 12430b: 48 dec %eax <== NOT EXECUTED 12430c: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 12430f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 124311: 72 0d jb 124320 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 124313: e8 88 67 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 124318: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12431e: eb 4c jmp 12436c <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 124320: 8b 5f 50 mov 0x50(%edi),%ebx <== NOT EXECUTED 124323: 31 d2 xor %edx,%edx <== NOT EXECUTED 124325: 39 de cmp %ebx,%esi <== NOT EXECUTED 124327: 7e 53 jle 12437c <== NOT EXECUTED /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 124329: 89 f0 mov %esi,%eax <== NOT EXECUTED 12432b: 99 cltd <== NOT EXECUTED 12432c: f7 f9 idiv %ecx <== NOT EXECUTED 12432e: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 124331: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124333: 99 cltd <== NOT EXECUTED 124334: f7 f9 idiv %ecx <== NOT EXECUTED 124336: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 124339: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12433b: eb 35 jmp 124372 <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { 12433d: 50 push %eax <== NOT EXECUTED 12433e: 50 push %eax <== NOT EXECUTED 12433f: 53 push %ebx <== NOT EXECUTED 124340: 57 push %edi <== NOT EXECUTED 124341: e8 fe fe ff ff call 124244 <== NOT EXECUTED 124346: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124349: 85 c0 test %eax,%eax <== NOT EXECUTED 12434b: 74 24 je 124371 <== NOT EXECUTED 12434d: eb 0d jmp 12435c <== NOT EXECUTED for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 12434f: 51 push %ecx <== NOT EXECUTED 124350: 51 push %ecx <== NOT EXECUTED 124351: 53 push %ebx <== NOT EXECUTED 124352: 57 push %edi <== NOT EXECUTED 124353: e8 4f fc ff ff call 123fa7 <== NOT EXECUTED * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { for ( ; block>=old_blocks ; block-- ) { 124358: 4b dec %ebx <== NOT EXECUTED 124359: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12435c: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 12435f: 73 ee jae 12434f <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 124361: e8 3a 67 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 124366: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 12436c: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 12436f: eb 0b jmp 12437c <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 124371: 43 inc %ebx <== NOT EXECUTED 124372: 3b 5d f0 cmp -0x10(%ebp),%ebx <== NOT EXECUTED 124375: 76 c6 jbe 12433d <== NOT EXECUTED /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 124377: 89 77 50 mov %esi,0x50(%edi) <== NOT EXECUTED 12437a: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 12437c: 89 d0 mov %edx,%eax <== NOT EXECUTED 12437e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124381: 5b pop %ebx <== NOT EXECUTED 124382: 5e pop %esi <== NOT EXECUTED 124383: 5f pop %edi <== NOT EXECUTED 124384: c9 leave <== NOT EXECUTED 124385: c3 ret <== NOT EXECUTED 00123e1a : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 123e1a: 55 push %ebp <== NOT EXECUTED 123e1b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123e1d: 57 push %edi <== NOT EXECUTED 123e1e: 56 push %esi <== NOT EXECUTED 123e1f: 53 push %ebx <== NOT EXECUTED 123e20: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 123e23: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 123e26: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 123e29: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 123e2c: 85 f6 test %esi,%esi <== NOT EXECUTED 123e2e: 75 11 jne 123e41 <== NOT EXECUTED 123e30: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 123e35: 68 9c d2 13 00 push $0x13d29c <== NOT EXECUTED 123e3a: 68 86 03 00 00 push $0x386 <== NOT EXECUTED 123e3f: eb 15 jmp 123e56 <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 123e41: 83 7e 4c 05 cmpl $0x5,0x4c(%esi) <== NOT EXECUTED 123e45: 74 19 je 123e60 <== NOT EXECUTED 123e47: 68 e9 d1 13 00 push $0x13d1e9 <== NOT EXECUTED 123e4c: 68 9c d2 13 00 push $0x13d29c <== NOT EXECUTED 123e51: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED 123e56: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 123e5b: e8 64 5e fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 123e60: a1 98 69 14 00 mov 0x146998,%eax <== NOT EXECUTED 123e65: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 123e68: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 123e6b: 48 dec %eax <== NOT EXECUTED 123e6c: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 123e6e: 77 2f ja 123e9f <== NOT EXECUTED #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 123e70: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 123e73: 85 ff test %edi,%edi <== NOT EXECUTED 123e75: 74 23 je 123e9a <== NOT EXECUTED if ( !p ) { 123e77: 85 c0 test %eax,%eax <== NOT EXECUTED 123e79: 75 10 jne 123e8b <== NOT EXECUTED p = memfile_alloc_block(); 123e7b: e8 78 ff ff ff call 123df8 <== NOT EXECUTED if ( !p ) 123e80: 85 c0 test %eax,%eax <== NOT EXECUTED 123e82: 0f 84 13 01 00 00 je 123f9b <== NOT EXECUTED return 0; info->indirect = p; 123e88: 89 46 54 mov %eax,0x54(%esi) <== NOT EXECUTED } return &info->indirect[ my_block ]; 123e8b: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED 123e92: 03 56 54 add 0x54(%esi),%edx <== NOT EXECUTED 123e95: e9 03 01 00 00 jmp 123f9d <== NOT EXECUTED } if ( !p ) return 0; return &info->indirect[ my_block ]; 123e9a: 8d 14 98 lea (%eax,%ebx,4),%edx <== NOT EXECUTED 123e9d: eb 6a jmp 123f09 <== NOT EXECUTED /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 123e9f: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 123ea2: 41 inc %ecx <== NOT EXECUTED 123ea3: 0f af 4d e4 imul -0x1c(%ebp),%ecx <== NOT EXECUTED 123ea7: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 123eaa: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 123eac: 77 68 ja 123f16 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 123eae: 2b 5d e4 sub -0x1c(%ebp),%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 123eb1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 123eb3: 31 d2 xor %edx,%edx <== NOT EXECUTED 123eb5: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 123eb8: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 123ebb: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 123ebd: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 123ec0: 85 ff test %edi,%edi <== NOT EXECUTED 123ec2: 74 34 je 123ef8 <== NOT EXECUTED if ( !p ) { 123ec4: 85 c0 test %eax,%eax <== NOT EXECUTED 123ec6: 75 10 jne 123ed8 <== NOT EXECUTED p = memfile_alloc_block(); 123ec8: e8 2b ff ff ff call 123df8 <== NOT EXECUTED if ( !p ) 123ecd: 85 c0 test %eax,%eax <== NOT EXECUTED 123ecf: 0f 84 c6 00 00 00 je 123f9b <== NOT EXECUTED return 0; info->doubly_indirect = p; 123ed5: 89 46 58 mov %eax,0x58(%esi) <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 123ed8: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 123edb: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 123edd: 85 c0 test %eax,%eax <== NOT EXECUTED 123edf: 75 0f jne 123ef0 <== NOT EXECUTED p1 = memfile_alloc_block(); 123ee1: e8 12 ff ff ff call 123df8 <== NOT EXECUTED if ( !p1 ) 123ee6: 85 c0 test %eax,%eax <== NOT EXECUTED 123ee8: 0f 84 ad 00 00 00 je 123f9b <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 123eee: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 123ef0: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 123ef3: e9 85 00 00 00 jmp 123f7d <== NOT EXECUTED } if ( !p ) 123ef8: 85 c0 test %eax,%eax <== NOT EXECUTED 123efa: 0f 84 9b 00 00 00 je 123f9b <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 123f00: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly, singly, p, &p[singly] ); fflush(stdout); #endif return (block_p *)&p[ singly ]; 123f03: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 123f06: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 123f09: 85 c0 test %eax,%eax <== NOT EXECUTED 123f0b: 0f 85 8c 00 00 00 jne 123f9d <== NOT EXECUTED 123f11: e9 85 00 00 00 jmp 123f9b <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 123f16: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 123f19: 0f af 45 e4 imul -0x1c(%ebp),%eax <== NOT EXECUTED 123f1d: 48 dec %eax <== NOT EXECUTED 123f1e: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 123f20: 77 79 ja 123f9b <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 123f22: 29 cb sub %ecx,%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 123f24: 89 d8 mov %ebx,%eax <== NOT EXECUTED 123f26: 31 d2 xor %edx,%edx <== NOT EXECUTED 123f28: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 123f2b: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 123f2e: 31 d2 xor %edx,%edx <== NOT EXECUTED 123f30: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 123f33: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 123f36: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 123f38: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 123f3b: 85 ff test %edi,%edi <== NOT EXECUTED 123f3d: 74 43 je 123f82 <== NOT EXECUTED if ( !p ) { 123f3f: 85 c0 test %eax,%eax <== NOT EXECUTED 123f41: 75 0c jne 123f4f <== NOT EXECUTED p = memfile_alloc_block(); 123f43: e8 b0 fe ff ff call 123df8 <== NOT EXECUTED if ( !p ) 123f48: 85 c0 test %eax,%eax <== NOT EXECUTED 123f4a: 74 4f je 123f9b <== NOT EXECUTED return 0; info->triply_indirect = p; 123f4c: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 123f4f: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 123f52: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 123f54: 85 c0 test %eax,%eax <== NOT EXECUTED 123f56: 75 0b jne 123f63 <== NOT EXECUTED p1 = memfile_alloc_block(); 123f58: e8 9b fe ff ff call 123df8 <== NOT EXECUTED if ( !p1 ) 123f5d: 85 c0 test %eax,%eax <== NOT EXECUTED 123f5f: 74 3a je 123f9b <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 123f61: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 123f63: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 123f66: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED 123f69: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 123f6b: 85 c0 test %eax,%eax <== NOT EXECUTED 123f6d: 75 0b jne 123f7a <== NOT EXECUTED p2 = memfile_alloc_block(); 123f6f: e8 84 fe ff ff call 123df8 <== NOT EXECUTED if ( !p2 ) 123f74: 85 c0 test %eax,%eax <== NOT EXECUTED 123f76: 74 23 je 123f9b <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 123f78: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 123f7a: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 123f7d: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED 123f80: eb 1b jmp 123f9d <== NOT EXECUTED } if ( !p ) 123f82: 85 c0 test %eax,%eax <== NOT EXECUTED 123f84: 74 15 je 123f9b <== NOT EXECUTED #if 0 fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly ); fflush(stdout); #endif p1 = (block_p *) p[ triply ]; 123f86: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !p1 ) 123f89: 85 c0 test %eax,%eax <== NOT EXECUTED 123f8b: 74 0e je 123f9b <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 123f8d: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 123f90: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 123f93: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 123f96: 03 14 88 add (%eax,%ecx,4),%edx <== NOT EXECUTED 123f99: eb 02 jmp 123f9d <== NOT EXECUTED 123f9b: 31 d2 xor %edx,%edx <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 123f9d: 89 d0 mov %edx,%eax <== NOT EXECUTED 123f9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123fa2: 5b pop %ebx <== NOT EXECUTED 123fa3: 5e pop %esi <== NOT EXECUTED 123fa4: 5f pop %edi <== NOT EXECUTED 123fa5: c9 leave <== NOT EXECUTED 123fa6: c3 ret <== NOT EXECUTED 00124687 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 124687: 55 push %ebp <== NOT EXECUTED 124688: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12468a: 57 push %edi <== NOT EXECUTED 12468b: 56 push %esi <== NOT EXECUTED 12468c: 53 push %ebx <== NOT EXECUTED 12468d: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 124690: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124693: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 124697: 75 11 jne 1246aa <== NOT EXECUTED 124699: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 12469e: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 1246a3: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED 1246a8: eb 1d jmp 1246c7 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 1246aa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1246ad: 8b 48 4c mov 0x4c(%eax),%ecx <== NOT EXECUTED 1246b0: 8d 41 fb lea -0x5(%ecx),%eax <== NOT EXECUTED 1246b3: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1246b6: 76 19 jbe 1246d1 <== NOT EXECUTED 1246b8: 68 4c d2 13 00 push $0x13d24c <== NOT EXECUTED 1246bd: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 1246c2: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED 1246c7: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 1246cc: e8 f3 55 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 1246d1: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 1246d5: 75 11 jne 1246e8 <== NOT EXECUTED 1246d7: 68 97 d2 13 00 push $0x13d297 <== NOT EXECUTED 1246dc: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 1246e1: 68 58 02 00 00 push $0x258 <== NOT EXECUTED 1246e6: eb df jmp 1246c7 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 1246e8: 85 db test %ebx,%ebx <== NOT EXECUTED 1246ea: 75 13 jne 1246ff <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 1246ec: e8 af 63 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1246f1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1246f7: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 1246fa: e9 86 01 00 00 jmp 124885 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 1246ff: 83 f9 06 cmp $0x6,%ecx <== NOT EXECUTED 124702: 75 47 jne 12474b <== NOT EXECUTED unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 124704: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124707: 8b 52 50 mov 0x50(%edx),%edx <== NOT EXECUTED 12470a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12470d: 29 ca sub %ecx,%edx <== NOT EXECUTED 12470f: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 124712: 39 da cmp %ebx,%edx <== NOT EXECUTED 124714: 76 03 jbe 124719 <== NOT EXECUTED 124716: 89 5d c4 mov %ebx,-0x3c(%ebp) <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 124719: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 12471c: 8b 76 54 mov 0x54(%esi),%esi <== NOT EXECUTED 12471f: 01 75 0c add %esi,0xc(%ebp) <== NOT EXECUTED 124722: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 124725: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 124728: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 12472b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 12472d: 50 push %eax <== NOT EXECUTED 12472e: 50 push %eax <== NOT EXECUTED 12472f: 6a 00 push $0x0 <== NOT EXECUTED 124731: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 124734: 50 push %eax <== NOT EXECUTED 124735: e8 5a 59 fe ff call 10a094 <== NOT EXECUTED 12473a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12473d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 124740: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED return my_length; 124743: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 124746: e9 37 01 00 00 jmp 124882 <== NOT EXECUTED * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 12474b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12474e: 8b 48 50 mov 0x50(%eax),%ecx <== NOT EXECUTED 124751: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 124754: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 124757: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 124759: 76 05 jbe 124760 <== NOT EXECUTED my_length = the_jnode->info.file.size - start; 12475b: 89 cb mov %ecx,%ebx <== NOT EXECUTED 12475d: 2b 5d 0c sub 0xc(%ebp),%ebx <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 124760: 8b 3d 98 69 14 00 mov 0x146998,%edi <== NOT EXECUTED 124766: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 124769: 99 cltd <== NOT EXECUTED 12476a: f7 ff idiv %edi <== NOT EXECUTED 12476c: 89 d6 mov %edx,%esi <== NOT EXECUTED 12476e: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 124771: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if ( start_offset ) { 124774: 85 d2 test %edx,%edx <== NOT EXECUTED 124776: 75 0f jne 124787 <== NOT EXECUTED 124778: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 12477b: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED 12477e: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED 124785: eb 54 jmp 1247db <== NOT EXECUTED to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124787: 50 push %eax <== NOT EXECUTED 124788: 6a 00 push $0x0 <== NOT EXECUTED 12478a: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 12478d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124790: e8 85 f6 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 124795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124798: 85 c0 test %eax,%eax <== NOT EXECUTED 12479a: 75 14 jne 1247b0 <== NOT EXECUTED 12479c: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 1247a1: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 1247a6: 68 94 02 00 00 push $0x294 <== NOT EXECUTED 1247ab: e9 17 ff ff ff jmp 1246c7 <== NOT EXECUTED */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 1247b0: 89 fa mov %edi,%edx <== NOT EXECUTED 1247b2: 29 f2 sub %esi,%edx <== NOT EXECUTED 1247b4: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED 1247b7: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 1247b9: 76 03 jbe 1247be <== NOT EXECUTED 1247bb: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 1247be: 03 30 add (%eax),%esi <== NOT EXECUTED dest += to_copy; 1247c0: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 1247c3: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 1247c6: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1247c8: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED block++; 1247cb: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 1247ce: 40 inc %eax <== NOT EXECUTED 1247cf: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 1247d2: 2b 5d c0 sub -0x40(%ebp),%ebx <== NOT EXECUTED 1247d5: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 1247d8: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 1247db: 8b 0d 98 69 14 00 mov 0x146998,%ecx <== NOT EXECUTED 1247e1: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 1247e4: eb 42 jmp 124828 <== NOT EXECUTED while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1247e6: 57 push %edi <== NOT EXECUTED 1247e7: 6a 00 push $0x0 <== NOT EXECUTED 1247e9: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1247ec: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1247ef: e8 26 f6 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 1247f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1247f7: 85 c0 test %eax,%eax <== NOT EXECUTED 1247f9: 75 14 jne 12480f <== NOT EXECUTED 1247fb: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 124800: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 124805: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED 12480a: e9 b8 fe ff ff jmp 1246c7 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 12480f: 8b 30 mov (%eax),%esi <== NOT EXECUTED 124811: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 124814: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 124817: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED dest += to_copy; 124819: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED block++; 12481c: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 12481f: 2b 5d e0 sub -0x20(%ebp),%ebx <== NOT EXECUTED copied += to_copy; 124822: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 124825: 01 75 d8 add %esi,-0x28(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 124828: 3b 1d 98 69 14 00 cmp 0x146998,%ebx <== NOT EXECUTED 12482e: 73 b6 jae 1247e6 <== NOT EXECUTED * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 124830: 85 db test %ebx,%ebx <== NOT EXECUTED 124832: 74 35 je 124869 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124834: 56 push %esi <== NOT EXECUTED 124835: 6a 00 push $0x0 <== NOT EXECUTED 124837: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 12483a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12483d: e8 d8 f5 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 124842: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124845: 85 c0 test %eax,%eax <== NOT EXECUTED 124847: 75 14 jne 12485d <== NOT EXECUTED 124849: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 12484e: 68 d0 d2 13 00 push $0x13d2d0 <== NOT EXECUTED 124853: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED 124858: e9 6a fe ff ff jmp 1246c7 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 12485d: 8b 30 mov (%eax),%esi <== NOT EXECUTED 12485f: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 124862: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 124864: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED copied += my_length; 124866: 01 5d d8 add %ebx,-0x28(%ebp) <== NOT EXECUTED } IMFS_update_atime( the_jnode ); 124869: 53 push %ebx <== NOT EXECUTED 12486a: 53 push %ebx <== NOT EXECUTED 12486b: 6a 00 push $0x0 <== NOT EXECUTED 12486d: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 124870: 50 push %eax <== NOT EXECUTED 124871: e8 1e 58 fe ff call 10a094 <== NOT EXECUTED 124876: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124879: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12487c: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED return copied; 12487f: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 124882: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 124885: 89 c8 mov %ecx,%eax <== NOT EXECUTED 124887: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12488a: 5b pop %ebx <== NOT EXECUTED 12488b: 5e pop %esi <== NOT EXECUTED 12488c: 5f pop %edi <== NOT EXECUTED 12488d: c9 leave <== NOT EXECUTED 12488e: c3 ret <== NOT EXECUTED 0012403b : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 12403b: 55 push %ebp <== NOT EXECUTED 12403c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12403e: 57 push %edi <== NOT EXECUTED 12403f: 56 push %esi <== NOT EXECUTED 124040: 53 push %ebx <== NOT EXECUTED 124041: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124044: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 124048: 75 11 jne 12405b <== NOT EXECUTED 12404a: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 12404f: 68 e4 d2 13 00 push $0x13d2e4 <== NOT EXECUTED 124054: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED 124059: eb 18 jmp 124073 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 12405b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12405e: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 124062: 74 19 je 12407d <== NOT EXECUTED 124064: 68 e9 d1 13 00 push $0x13d1e9 <== NOT EXECUTED 124069: 68 e4 d2 13 00 push $0x13d2e4 <== NOT EXECUTED 12406e: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED 124073: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 124078: e8 47 5c fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Eventually this could be set smarter at each call to * memfile_free_blocks_in_table to greatly speed this up. */ to_free = IMFS_MEMFILE_BLOCK_SLOTS; 12407d: 8b 3d 98 69 14 00 mov 0x146998,%edi <== NOT EXECUTED 124083: c1 ef 02 shr $0x2,%edi <== NOT EXECUTED * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 124086: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124089: 83 7a 54 00 cmpl $0x0,0x54(%edx) <== NOT EXECUTED 12408d: 74 11 je 1240a0 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); 12408f: 50 push %eax <== NOT EXECUTED 124090: 50 push %eax <== NOT EXECUTED 124091: 57 push %edi <== NOT EXECUTED 124092: 89 d0 mov %edx,%eax <== NOT EXECUTED 124094: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 124097: 50 push %eax <== NOT EXECUTED 124098: e8 34 ff ff ff call 123fd1 <== NOT EXECUTED 12409d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->doubly_indirect ) { 1240a0: 31 db xor %ebx,%ebx <== NOT EXECUTED 1240a2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1240a5: 83 78 58 00 cmpl $0x0,0x58(%eax) <== NOT EXECUTED 1240a9: 75 24 jne 1240cf <== NOT EXECUTED 1240ab: eb 40 jmp 1240ed <== NOT EXECUTED for ( i=0 ; idoubly_indirect[i] ) { 1240ad: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1240b0: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED 1240b3: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED 1240ba: 83 3c 98 00 cmpl $0x0,(%eax,%ebx,4) <== NOT EXECUTED 1240be: 74 0e je 1240ce <== NOT EXECUTED memfile_free_blocks_in_table( 1240c0: 56 push %esi <== NOT EXECUTED 1240c1: 56 push %esi <== NOT EXECUTED 1240c2: 57 push %edi <== NOT EXECUTED 1240c3: 01 d0 add %edx,%eax <== NOT EXECUTED 1240c5: 50 push %eax <== NOT EXECUTED 1240c6: e8 06 ff ff ff call 123fd1 <== NOT EXECUTED 1240cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i <== NOT EXECUTED if ( info->doubly_indirect[i] ) { memfile_free_blocks_in_table( (block_p **)&info->doubly_indirect[i], to_free ); } } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); 1240db: 53 push %ebx <== NOT EXECUTED 1240dc: 53 push %ebx <== NOT EXECUTED 1240dd: 57 push %edi <== NOT EXECUTED 1240de: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1240e1: 83 c0 58 add $0x58,%eax <== NOT EXECUTED 1240e4: 50 push %eax <== NOT EXECUTED 1240e5: e8 e7 fe ff ff call 123fd1 <== NOT EXECUTED 1240ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->triply_indirect ) { 1240ed: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 1240f4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1240f7: 83 78 5c 00 cmpl $0x0,0x5c(%eax) <== NOT EXECUTED 1240fb: 75 5c jne 124159 <== NOT EXECUTED 1240fd: eb 79 jmp 124178 <== NOT EXECUTED 1240ff: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 124102: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 124105: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED for ( i=0 ; itriply_indirect[i]; 124108: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12410b: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 12410e: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 124111: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 124114: 85 c0 test %eax,%eax <== NOT EXECUTED 124116: 74 4e je 124166 <== NOT EXECUTED break; 124118: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12411a: 31 f6 xor %esi,%esi <== NOT EXECUTED 12411c: eb 15 jmp 124133 <== NOT EXECUTED for ( j=0 ; j <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 124123: 51 push %ecx <== NOT EXECUTED 124124: 51 push %ecx <== NOT EXECUTED 124125: 57 push %edi <== NOT EXECUTED 124126: 53 push %ebx <== NOT EXECUTED 124127: e8 a5 fe ff ff call 123fd1 <== NOT EXECUTED 12412c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j <== NOT EXECUTED if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 12413f: 52 push %edx <== NOT EXECUTED 124140: 52 push %edx <== NOT EXECUTED 124141: 57 push %edi <== NOT EXECUTED 124142: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124145: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 124148: 01 45 f0 add %eax,-0x10(%ebp) <== NOT EXECUTED 12414b: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 12414e: e8 7e fe ff ff call 123fd1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i <== NOT EXECUTED } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 124166: 50 push %eax <== NOT EXECUTED 124167: 50 push %eax <== NOT EXECUTED 124168: 57 push %edi <== NOT EXECUTED 124169: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12416c: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED 12416f: 50 push %eax <== NOT EXECUTED 124170: e8 5c fe ff ff call 123fd1 <== NOT EXECUTED 124175: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 124178: 31 c0 xor %eax,%eax <== NOT EXECUTED 12417a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12417d: 5b pop %ebx <== NOT EXECUTED 12417e: 5e pop %esi <== NOT EXECUTED 12417f: 5f pop %edi <== NOT EXECUTED 124180: c9 leave <== NOT EXECUTED 124181: c3 ret <== NOT EXECUTED 00123fa7 : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 123fa7: 55 push %ebp <== NOT EXECUTED 123fa8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123faa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED block_p *block_entry_ptr; block_p ptr; block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 123fad: 6a 00 push $0x0 <== NOT EXECUTED 123faf: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 123fb2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123fb5: e8 60 fe ff ff call 123e1a <== NOT EXECUTED ptr = *block_entry_ptr; 123fba: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_entry_ptr = 0; 123fbc: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 123fc2: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 123fc5: e8 15 fe ff ff call 123ddf <== NOT EXECUTED return 1; } 123fca: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 123fcf: c9 leave <== NOT EXECUTED 123fd0: c3 ret <== NOT EXECUTED 00124419 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 124419: 55 push %ebp <== NOT EXECUTED 12441a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12441c: 57 push %edi <== NOT EXECUTED 12441d: 56 push %esi <== NOT EXECUTED 12441e: 53 push %ebx <== NOT EXECUTED 12441f: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124422: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 124426: 75 11 jne 124439 <== NOT EXECUTED 124428: 68 96 d1 13 00 push $0x13d196 <== NOT EXECUTED 12442d: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 124432: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED 124437: eb 18 jmp 124451 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 124439: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12443c: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 124440: 74 19 je 12445b <== NOT EXECUTED 124442: 68 e9 d1 13 00 push $0x13d1e9 <== NOT EXECUTED 124447: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 12444c: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED 124451: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 124456: e8 69 58 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 12445b: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 12445f: 75 11 jne 124472 <== NOT EXECUTED 124461: 68 eb cc 13 00 push $0x13cceb <== NOT EXECUTED 124466: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 12446b: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED 124470: eb df jmp 124451 <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 124472: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 124476: 75 0d jne 124485 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 124478: e8 23 66 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 12447d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 124483: eb 29 jmp 1244ae <== NOT EXECUTED /* * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + length; 124485: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 124488: 03 45 0c add 0xc(%ebp),%eax <== NOT EXECUTED if ( last_byte > the_jnode->info.file.size ) { 12448b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12448e: 3b 42 50 cmp 0x50(%edx),%eax <== NOT EXECUTED 124491: 76 27 jbe 1244ba <== NOT EXECUTED status = IMFS_memfile_extend( the_jnode, last_byte ); 124493: 51 push %ecx <== NOT EXECUTED 124494: 51 push %ecx <== NOT EXECUTED 124495: 50 push %eax <== NOT EXECUTED 124496: 52 push %edx <== NOT EXECUTED 124497: e8 17 fe ff ff call 1242b3 <== NOT EXECUTED if ( status ) 12449c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12449f: 85 c0 test %eax,%eax <== NOT EXECUTED 1244a1: 74 17 je 1244ba <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1244a3: e8 f8 65 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1244a8: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1244ae: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 1244b5: e9 24 01 00 00 jmp 1245de <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 1244ba: 8b 1d 98 69 14 00 mov 0x146998,%ebx <== NOT EXECUTED 1244c0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1244c3: 99 cltd <== NOT EXECUTED 1244c4: f7 fb idiv %ebx <== NOT EXECUTED 1244c6: 89 d7 mov %edx,%edi <== NOT EXECUTED 1244c8: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 1244cb: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if ( start_offset ) { 1244ce: 85 d2 test %edx,%edx <== NOT EXECUTED 1244d0: 75 12 jne 1244e4 <== NOT EXECUTED 1244d2: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 1244d5: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1244d8: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 1244db: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 1244e2: eb 50 jmp 124534 <== NOT EXECUTED to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1244e4: 50 push %eax <== NOT EXECUTED 1244e5: 6a 00 push $0x0 <== NOT EXECUTED 1244e7: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 1244ea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1244ed: e8 28 f9 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 1244f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1244f5: 85 c0 test %eax,%eax <== NOT EXECUTED 1244f7: 75 14 jne 12450d <== NOT EXECUTED 1244f9: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 1244fe: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 124503: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED 124508: e9 44 ff ff ff jmp 124451 <== NOT EXECUTED */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 12450d: 89 da mov %ebx,%edx <== NOT EXECUTED 12450f: 29 fa sub %edi,%edx <== NOT EXECUTED 124511: 3b 55 14 cmp 0x14(%ebp),%edx <== NOT EXECUTED 124514: 76 03 jbe 124519 <== NOT EXECUTED 124516: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 124519: 03 38 add (%eax),%edi <== NOT EXECUTED src += to_copy; 12451b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 12451e: 89 d1 mov %edx,%ecx <== NOT EXECUTED 124520: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124522: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 124525: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 124528: 40 inc %eax <== NOT EXECUTED 124529: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 12452c: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 12452f: 29 d3 sub %edx,%ebx <== NOT EXECUTED copied += to_copy; 124531: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 124534: 8b 15 98 69 14 00 mov 0x146998,%edx <== NOT EXECUTED 12453a: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 12453d: eb 42 jmp 124581 <== NOT EXECUTED while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 12453f: 57 push %edi <== NOT EXECUTED 124540: 6a 00 push $0x0 <== NOT EXECUTED 124542: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 124545: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124548: e8 cd f8 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 12454d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124550: 85 c0 test %eax,%eax <== NOT EXECUTED 124552: 75 14 jne 124568 <== NOT EXECUTED 124554: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 124559: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 12455e: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED 124563: e9 e9 fe ff ff jmp 124451 <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 124568: 8b 38 mov (%eax),%edi <== NOT EXECUTED src += to_copy; 12456a: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 12456d: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 124570: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124572: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 124575: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 124578: 2b 5d c4 sub -0x3c(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 12457b: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 12457e: 01 45 dc add %eax,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 124581: 3b 1d 98 69 14 00 cmp 0x146998,%ebx <== NOT EXECUTED 124587: 73 b6 jae 12453f <== NOT EXECUTED */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 124589: 85 db test %ebx,%ebx <== NOT EXECUTED 12458b: 74 35 je 1245c2 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 12458d: 56 push %esi <== NOT EXECUTED 12458e: 6a 00 push $0x0 <== NOT EXECUTED 124590: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 124593: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124596: e8 7f f8 ff ff call 123e1a <== NOT EXECUTED assert( block_ptr ); 12459b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12459e: 85 c0 test %eax,%eax <== NOT EXECUTED 1245a0: 75 14 jne 1245b6 <== NOT EXECUTED 1245a2: 68 19 d2 13 00 push $0x13d219 <== NOT EXECUTED 1245a7: 68 bc d2 13 00 push $0x13d2bc <== NOT EXECUTED 1245ac: 68 44 03 00 00 push $0x344 <== NOT EXECUTED 1245b1: e9 9b fe ff ff jmp 124451 <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); 1245b6: 8b 38 mov (%eax),%edi <== NOT EXECUTED 1245b8: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 1245bb: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1245bd: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED my_length = 0; copied += to_copy; 1245bf: 01 5d dc add %ebx,-0x24(%ebp) <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); 1245c2: 53 push %ebx <== NOT EXECUTED 1245c3: 53 push %ebx <== NOT EXECUTED 1245c4: 6a 00 push $0x0 <== NOT EXECUTED 1245c6: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 1245c9: 50 push %eax <== NOT EXECUTED 1245ca: e8 c5 5a fe ff call 10a094 <== NOT EXECUTED 1245cf: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1245d2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1245d5: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 1245d8: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED 1245db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return copied; } 1245de: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 1245e1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1245e4: 5b pop %ebx <== NOT EXECUTED 1245e5: 5e pop %esi <== NOT EXECUTED 1245e6: 5f pop %edi <== NOT EXECUTED 1245e7: c9 leave <== NOT EXECUTED 1245e8: c3 ret <== NOT EXECUTED 0010c920 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10c920: 55 push %ebp <== NOT EXECUTED 10c921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c923: 57 push %edi <== NOT EXECUTED 10c924: 56 push %esi <== NOT EXECUTED 10c925: 53 push %ebx <== NOT EXECUTED 10c926: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 10c929: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c92c: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10c92f: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *new_node; int result; char new_name[ IMFS_NAME_MAX + 1 ]; IMFS_types_union info; IMFS_get_token( token, new_name, &result ); 10c932: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c935: 50 push %eax <== NOT EXECUTED 10c936: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10c939: 50 push %eax <== NOT EXECUTED 10c93a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c93d: e8 7a fe ff ff call 10c7bc <== NOT EXECUTED /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10c942: 89 f8 mov %edi,%eax <== NOT EXECUTED 10c944: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10c949: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c94c: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 10c951: 74 34 je 10c987 <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10c953: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED 10c958: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED 10c95d: 74 2d je 10c98c <== NOT EXECUTED type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10c95f: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 10c964: 74 07 je 10c96d <== NOT EXECUTED 10c966: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 10c96b: 75 0d jne 10c97a <== NOT EXECUTED type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10c96d: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED 10c970: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED 10c973: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED 10c978: eb 12 jmp 10c98c <== NOT EXECUTED } else { rtems_set_errno_and_return_minus_one( EINVAL ); 10c97a: e8 31 1d 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c97f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c985: eb 2e jmp 10c9b5 <== NOT EXECUTED 10c987: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10c98c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c98f: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10c992: 50 push %eax <== NOT EXECUTED 10c993: 57 push %edi <== NOT EXECUTED 10c994: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10c997: 50 push %eax <== NOT EXECUTED 10c998: 52 push %edx <== NOT EXECUTED 10c999: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10c99c: e8 87 16 00 00 call 10e028 <== NOT EXECUTED new_name, mode, &info ); if ( !new_node ) 10c9a1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10c9a4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c9a6: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9a8: 75 0e jne 10c9b8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 10c9aa: e8 01 1d 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10c9af: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10c9b5: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED return 0; } 10c9b8: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c9ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9bd: 5b pop %ebx <== NOT EXECUTED 10c9be: 5e pop %esi <== NOT EXECUTED 10c9bf: 5f pop %edi <== NOT EXECUTED 10c9c0: c9 leave <== NOT EXECUTED 10c9c1: c3 ret <== NOT EXECUTED 001099c8 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 1099c8: 55 push %ebp <== NOT EXECUTED 1099c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099cb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1099ce: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 1099d1: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 1099d4: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 1099d8: 74 10 je 1099ea <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 1099da: e8 c1 10 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 1099df: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1099e5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1099e8: eb 05 jmp 1099ef <== NOT EXECUTED /* * Set mt_fs pointer to point to the mount table entry for * the mounted file system. */ node->info.directory.mt_fs = mt_entry; 1099ea: 89 50 5c mov %edx,0x5c(%eax) <== NOT EXECUTED 1099ed: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1099ef: c9 leave <== NOT EXECUTED 1099f0: c3 ret <== NOT EXECUTED 0010c9c4 : #include "imfs.h" rtems_filesystem_node_types_t IMFS_node_type( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10c9c4: 55 push %ebp <== NOT EXECUTED 10c9c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c9ca: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c9cc: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED IMFS_jnode_t *node; node = pathloc->node_access; return node->type; } 10c9cf: c9 leave <== NOT EXECUTED 10c9d0: c3 ret <== NOT EXECUTED 00109a04 : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 109a04: 55 push %ebp <== NOT EXECUTED 109a05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a07: 53 push %ebx <== NOT EXECUTED 109a08: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109a0b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *node; int i; node = loc->node_access; 109a0e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109a11: 8b 08 mov (%eax),%ecx <== NOT EXECUTED if ( node->type != IMFS_SYM_LINK ) 109a13: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a15: 83 79 4c 04 cmpl $0x4,0x4c(%ecx) <== NOT EXECUTED 109a19: 74 14 je 109a2f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109a1b: e8 80 10 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109a20: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109a26: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 109a29: eb 13 jmp 109a3e <== NOT EXECUTED for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) buf[i] = node->info.sym_link.name[i]; 109a2b: 88 04 13 mov %al,(%ebx,%edx,1) <== NOT EXECUTED node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 109a2e: 42 inc %edx <== NOT EXECUTED 109a2f: 3b 55 10 cmp 0x10(%ebp),%edx <== NOT EXECUTED 109a32: 73 0a jae 109a3e <== NOT EXECUTED 109a34: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 109a37: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 109a3a: 84 c0 test %al,%al <== NOT EXECUTED 109a3c: 75 ed jne 109a2b <== NOT EXECUTED buf[i] = node->info.sym_link.name[i]; return i; } 109a3e: 89 d0 mov %edx,%eax <== NOT EXECUTED 109a40: 5a pop %edx <== NOT EXECUTED 109a41: 5b pop %ebx <== NOT EXECUTED 109a42: c9 leave <== NOT EXECUTED 109a43: c3 ret <== NOT EXECUTED 0010c9d4 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10c9d4: 55 push %ebp <== NOT EXECUTED 10c9d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9d7: 56 push %esi <== NOT EXECUTED 10c9d8: 53 push %ebx <== NOT EXECUTED 10c9d9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10c9dc: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10c9df: 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 ) { 10c9e1: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 10c9e5: 74 13 je 10c9fa <== NOT EXECUTED 10c9e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9ea: 53 push %ebx <== NOT EXECUTED 10c9eb: e8 60 0c 00 00 call 10d650 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10c9f0: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10c9f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10c9fa: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 10c9fe: 50 push %eax <== NOT EXECUTED 10c9ff: 50 push %eax <== NOT EXECUTED 10ca00: 6a 00 push $0x0 <== NOT EXECUTED 10ca02: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ca05: 50 push %eax <== NOT EXECUTED 10ca06: e8 3d 03 00 00 call 10cd48 <== NOT EXECUTED 10ca0b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ca0e: 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) ) { 10ca11: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ca14: e8 df 03 00 00 call 10cdf8 <== NOT EXECUTED 10ca19: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca1c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca1e: 75 40 jne 10ca60 <== NOT EXECUTED 10ca20: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 10ca25: 75 39 jne 10ca60 <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10ca27: 8b 15 6c a9 11 00 mov 0x11a96c,%edx <== NOT EXECUTED 10ca2d: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10ca30: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10ca32: 75 07 jne 10ca3b <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 10ca34: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 10ca3b: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10ca3f: 75 13 jne 10ca54 <== NOT EXECUTED if ( the_jnode->info.sym_link.name ) 10ca41: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10ca44: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca46: 74 0c je 10ca54 <== NOT EXECUTED free( (void*) the_jnode->info.sym_link.name ); 10ca48: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca4b: 50 push %eax <== NOT EXECUTED 10ca4c: e8 17 9a ff ff call 106468 <== NOT EXECUTED 10ca51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } free( the_jnode ); 10ca54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca57: 53 push %ebx <== NOT EXECUTED 10ca58: e8 0b 9a ff ff call 106468 <== NOT EXECUTED 10ca5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10ca60: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca62: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca65: 5b pop %ebx <== NOT EXECUTED 10ca66: 5e pop %esi <== NOT EXECUTED 10ca67: c9 leave <== NOT EXECUTED 10ca68: c3 ret <== NOT EXECUTED 0010ca6c : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10ca6c: 55 push %ebp <== NOT EXECUTED 10ca6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca6f: 53 push %ebx <== NOT EXECUTED 10ca70: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ca73: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10ca76: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca79: 8b 08 mov (%eax),%ecx <== NOT EXECUTED switch ( the_jnode->type ) { 10ca7b: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10ca7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10ca81: 74 25 je 10caa8 <== NOT EXECUTED 10ca83: 7f 07 jg 10ca8c <== NOT EXECUTED 10ca85: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ca88: 75 27 jne 10cab1 <== NOT EXECUTED 10ca8a: eb 07 jmp 10ca93 <== NOT EXECUTED 10ca8c: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10ca8f: 7f 20 jg 10cab1 <== NOT EXECUTED 10ca91: eb 0d jmp 10caa0 <== NOT EXECUTED case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10ca93: 8b 51 54 mov 0x54(%ecx),%edx <== NOT EXECUTED 10ca96: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10ca99: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10ca9b: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10ca9e: eb 21 jmp 10cac1 <== NOT EXECUTED break; case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10caa0: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10caa3: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 10caa6: eb 19 jmp 10cac1 <== NOT EXECUTED break; case IMFS_SYM_LINK: buf->st_size = 0; 10caa8: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10caaf: eb 10 jmp 10cac1 <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10cab1: e8 fa 1b 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cab6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cabc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cabf: eb 36 jmp 10caf7 <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 10cac1: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10cac4: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 10cac7: 8b 41 34 mov 0x34(%ecx),%eax <== NOT EXECUTED 10caca: 66 89 43 10 mov %ax,0x10(%ebx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 10cace: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 10cad1: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 10cad4: 8b 41 3c mov 0x3c(%ecx),%eax <== NOT EXECUTED 10cad7: 66 89 43 12 mov %ax,0x12(%ebx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 10cadb: 66 8b 41 3e mov 0x3e(%ecx),%ax <== NOT EXECUTED 10cadf: 66 89 43 14 mov %ax,0x14(%ebx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 10cae3: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10cae6: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 10cae9: 8b 41 44 mov 0x44(%ecx),%eax <== NOT EXECUTED 10caec: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 10caef: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 10caf2: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED 10caf5: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10caf7: 5a pop %edx <== NOT EXECUTED 10caf8: 5b pop %ebx <== NOT EXECUTED 10caf9: c9 leave <== NOT EXECUTED 10cafa: c3 ret <== NOT EXECUTED 00109a44 : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 109a44: 55 push %ebp <== NOT EXECUTED 109a45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a47: 53 push %ebx <== NOT EXECUTED 109a48: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED /* * Remove any separators at the end of the string. */ IMFS_get_token( node_name, new_name, &i ); 109a4b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109a4e: 50 push %eax <== NOT EXECUTED 109a4f: 8d 5d c7 lea -0x39(%ebp),%ebx <== NOT EXECUTED 109a52: 53 push %ebx <== NOT EXECUTED 109a53: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109a56: e8 bd fc ff ff call 109718 <== NOT EXECUTED /* * Duplicate link name */ info.sym_link.name = strdup( link_name); 109a5b: 58 pop %eax <== NOT EXECUTED 109a5c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109a5f: e8 4c 55 02 00 call 12efb0 <== NOT EXECUTED 109a64: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED if (info.sym_link.name == NULL) { 109a67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a6a: 85 c0 test %eax,%eax <== NOT EXECUTED 109a6c: 75 10 jne 109a7e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM); 109a6e: e8 2d 10 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109a73: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 109a79: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 109a7c: eb 3c jmp 109aba <== NOT EXECUTED /* * Create a new link node. */ new_node = IMFS_create_node( 109a7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a81: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 109a84: 50 push %eax <== NOT EXECUTED 109a85: 68 ff a1 00 00 push $0xa1ff <== NOT EXECUTED 109a8a: 53 push %ebx <== NOT EXECUTED 109a8b: 6a 04 push $0x4 <== NOT EXECUTED 109a8d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109a90: e8 53 45 01 00 call 11dfe8 <== NOT EXECUTED new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if (new_node == NULL) { 109a95: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109a98: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a9a: 85 c0 test %eax,%eax <== NOT EXECUTED 109a9c: 75 1c jne 109aba <== NOT EXECUTED free( info.sym_link.name); 109a9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109aa1: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 109aa4: e8 73 05 00 00 call 10a01c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM); 109aa9: e8 f2 0f 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109aae: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 109ab4: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 109ab7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 109aba: 89 d0 mov %edx,%eax <== NOT EXECUTED 109abc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109abf: c9 leave <== NOT EXECUTED 109ac0: c3 ret <== NOT EXECUTED 00109ac4 : #include int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) { 109ac4: 55 push %ebp <== NOT EXECUTED 109ac5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ac7: 57 push %edi <== NOT EXECUTED 109ac8: 56 push %esi <== NOT EXECUTED 109ac9: 53 push %ebx <== NOT EXECUTED 109aca: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 109acd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ad0: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 109ad2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) <== NOT EXECUTED 109ad6: 75 76 jne 109b4e <== NOT EXECUTED if ( !node->info.hard_link.link_node ) 109ad8: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 109adb: 85 c0 test %eax,%eax <== NOT EXECUTED 109add: 75 10 jne 109aef <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109adf: e8 bc 0f 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109ae4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109aea: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 109aed: eb 71 jmp 109b60 <== NOT EXECUTED the_link = *loc; 109aef: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 109af2: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109af7: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109afa: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_link.node_access = node->info.hard_link.link_node; 109afc: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &the_link ); 109aff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b02: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 109b05: 57 push %edi <== NOT EXECUTED 109b06: e8 15 46 01 00 call 11e120 <== NOT EXECUTED /* * If removing the last hard link to a node, then we need * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) 109b0b: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED 109b0e: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 109b11: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b14: 66 83 f8 01 cmp $0x1,%ax <== NOT EXECUTED 109b18: 75 16 jne 109b30 <== NOT EXECUTED { result = (*the_link.handlers->rmnod_h)( &the_link ); 109b1a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b1d: 57 push %edi <== NOT EXECUTED 109b1e: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109b21: ff 50 34 call *0x34(%eax) <== NOT EXECUTED if ( result != 0 ) 109b24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b27: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 109b2a: 85 c0 test %eax,%eax <== NOT EXECUTED 109b2c: 74 20 je 109b4e <== NOT EXECUTED 109b2e: eb 30 jmp 109b60 <== NOT EXECUTED return -1; } else { node->info.hard_link.link_node->st_nlink --; 109b30: 48 dec %eax <== NOT EXECUTED 109b31: 66 89 42 34 mov %ax,0x34(%edx) <== NOT EXECUTED IMFS_update_ctime( node->info.hard_link.link_node ); 109b35: 50 push %eax <== NOT EXECUTED 109b36: 50 push %eax <== NOT EXECUTED 109b37: 6a 00 push $0x0 <== NOT EXECUTED 109b39: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 109b3c: 50 push %eax <== NOT EXECUTED 109b3d: e8 52 05 00 00 call 10a094 <== NOT EXECUTED 109b42: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED 109b45: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109b48: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED 109b4b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 109b4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b51: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109b54: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 109b57: 52 push %edx <== NOT EXECUTED 109b58: ff 50 34 call *0x34(%eax) <== NOT EXECUTED 109b5b: 89 c2 mov %eax,%edx <== NOT EXECUTED 109b5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 109b60: 89 d0 mov %edx,%eax <== NOT EXECUTED 109b62: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109b65: 5b pop %ebx <== NOT EXECUTED 109b66: 5e pop %esi <== NOT EXECUTED 109b67: 5f pop %edi <== NOT EXECUTED 109b68: c9 leave <== NOT EXECUTED 109b69: c3 ret <== NOT EXECUTED 00109b6c : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 109b6c: 55 push %ebp <== NOT EXECUTED 109b6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b6f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 109b72: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109b75: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 109b78: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 109b7c: 74 0d je 109b8b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 109b7e: e8 1d 0f 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109b83: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 109b89: eb 11 jmp 109b9c <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 109b8b: 83 78 5c 00 cmpl $0x0,0x5c(%eax) <== NOT EXECUTED 109b8f: 75 10 jne 109ba1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 109b91: e8 0a 0f 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109b96: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109b9c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109b9f: eb 09 jmp 109baa <== NOT EXECUTED /* * Set the mt_fs pointer to indicate that there is no longer * a file system mounted to this point. */ node->info.directory.mt_fs = NULL; 109ba1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) <== NOT EXECUTED 109ba8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 109baa: c9 leave <== NOT EXECUTED 109bab: c3 ret <== NOT EXECUTED 00109bac : int IMFS_utime( rtems_filesystem_location_info_t *pathloc, /* IN */ time_t actime, /* IN */ time_t modtime /* IN */ ) { 109bac: 55 push %ebp <== NOT EXECUTED 109bad: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 109baf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109bb2: 8b 10 mov (%eax),%edx <== NOT EXECUTED the_jnode->stat_atime = actime; 109bb4: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109bb7: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED the_jnode->stat_mtime = modtime; 109bba: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 109bbd: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED return 0; } 109bc0: 31 c0 xor %eax,%eax <== NOT EXECUTED 109bc2: c9 leave <== NOT EXECUTED 109bc3: c3 ret <== NOT EXECUTED 001065ec : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 1065ec: 55 push %ebp <== NOT EXECUTED 1065ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1065ef: 57 push %edi <== NOT EXECUTED 1065f0: 56 push %esi <== NOT EXECUTED 1065f1: 53 push %ebx <== NOT EXECUTED 1065f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1065f5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1065f8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers ) 1065fb: a1 74 ae 11 00 mov 0x11ae74,%eax <== NOT EXECUTED 106600: 85 c0 test %eax,%eax <== NOT EXECUTED 106602: 74 02 je 106606 <== NOT EXECUTED (*rtems_malloc_statistics_helpers->initialize)(); 106604: ff 10 call *(%eax) <== NOT EXECUTED /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 106606: e8 79 ff ff ff call 106584 <== NOT EXECUTED starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 10660b: a1 78 ae 11 00 mov 0x11ae78,%eax <== NOT EXECUTED 106610: 89 f2 mov %esi,%edx <== NOT EXECUTED 106612: 85 c0 test %eax,%eax <== NOT EXECUTED 106614: 74 0d je 106623 <== NOT EXECUTED starting_address = (*rtems_malloc_sbrk_helpers->initialize)( 106616: 52 push %edx <== NOT EXECUTED 106617: 52 push %edx <== NOT EXECUTED 106618: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10661b: 56 push %esi <== NOT EXECUTED 10661c: ff 10 call *(%eax) <== NOT EXECUTED 10661e: 89 c2 mov %eax,%edx <== NOT EXECUTED 106620: 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() ) 106623: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 106628: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10662c: 74 08 je 106636 <== NOT EXECUTED memset( starting_address, 0, length ); 10662e: 31 c0 xor %eax,%eax <== NOT EXECUTED 106630: 89 d7 mov %edx,%edi <== NOT EXECUTED 106632: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 106634: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 106636: 6a 04 push $0x4 <== NOT EXECUTED 106638: 53 push %ebx <== NOT EXECUTED 106639: 52 push %edx <== NOT EXECUTED 10663a: 68 b8 c8 11 00 push $0x11c8b8 <== NOT EXECUTED 10663f: e8 1c 39 00 00 call 109f60 <_Heap_Initialize> <== NOT EXECUTED &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 106644: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106647: 85 c0 test %eax,%eax <== NOT EXECUTED 106649: 75 0a jne 106655 <== NOT EXECUTED rtems_fatal_error_occurred( status ); 10664b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10664e: 6a 00 push $0x0 <== NOT EXECUTED 106650: e8 0b 31 00 00 call 109760 <== NOT EXECUTED rtems_print_buffer( (start + length) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif MSBUMP(space_available, length); 106655: 01 1d 10 c9 11 00 add %ebx,0x11c910 <== NOT EXECUTED } 10665b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10665e: 5b pop %ebx <== NOT EXECUTED 10665f: 5e pop %esi <== NOT EXECUTED 106660: 5f pop %edi <== NOT EXECUTED 106661: c9 leave <== NOT EXECUTED 106662: c3 ret <== NOT EXECUTED 001085be : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 1085be: 55 push %ebp <== NOT EXECUTED 1085bf: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1085c1: 57 push %edi <== NOT EXECUTED 1085c2: 56 push %esi <== NOT EXECUTED 1085c3: 53 push %ebx <== NOT EXECUTED 1085c4: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1085c7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED void *high_water_mark; void *current; Stack_Control *stack; char name[5]; if ( !the_thread ) 1085ca: 85 db test %ebx,%ebx <== NOT EXECUTED 1085cc: 0f 84 fc 00 00 00 je 1086ce <== NOT EXECUTED return; if ( !print_handler ) 1085d2: a1 80 69 14 00 mov 0x146980,%eax <== NOT EXECUTED 1085d7: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 1085da: 85 c0 test %eax,%eax <== NOT EXECUTED 1085dc: 0f 84 ec 00 00 00 je 1086ce <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { 1085e2: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 1085e5: 75 1d jne 108604 <== NOT EXECUTED if (Stack_check_Interrupt_stack.area) { 1085e7: 83 3d 84 9a 15 00 00 cmpl $0x0,0x159a84 <== NOT EXECUTED 1085ee: 0f 84 da 00 00 00 je 1086ce <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; current = 0; } else return; 1085f4: 31 db xor %ebx,%ebx <== NOT EXECUTED 1085f6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 1085fd: be 80 9a 15 00 mov $0x159a80,%esi <== NOT EXECUTED 108602: eb 0f jmp 108613 <== NOT EXECUTED } else { stack = &the_thread->Start.Initial_stack; 108604: 8d b3 c4 00 00 00 lea 0xc4(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10860a: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED 108610: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 108613: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 108616: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 108619: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10861b: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED 10861e: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 108621: 50 push %eax <== NOT EXECUTED 108622: 57 push %edi <== NOT EXECUTED 108623: e8 6b ff ff ff call 108593 <== NOT EXECUTED if ( high_water_mark ) 108628: 5a pop %edx <== NOT EXECUTED 108629: 59 pop %ecx <== NOT EXECUTED 10862a: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 108631: 85 c0 test %eax,%eax <== NOT EXECUTED 108633: 74 09 je 10863e <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 108635: 03 7d d8 add -0x28(%ebp),%edi <== NOT EXECUTED 108638: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED 10863b: 29 45 dc sub %eax,-0x24(%ebp) <== NOT EXECUTED else used = 0; if ( the_thread ) { 10863e: 85 db test %ebx,%ebx <== NOT EXECUTED 108640: 74 26 je 108668 <== NOT EXECUTED (*print_handler)( 108642: 50 push %eax <== NOT EXECUTED 108643: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 108646: 50 push %eax <== NOT EXECUTED 108647: 6a 05 push $0x5 <== NOT EXECUTED 108649: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10864c: e8 0f 50 00 00 call 10d660 <== NOT EXECUTED 108651: 50 push %eax <== NOT EXECUTED 108652: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 108655: 68 91 a8 13 00 push $0x13a891 <== NOT EXECUTED 10865a: ff 35 7c 69 14 00 pushl 0x14697c <== NOT EXECUTED 108660: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED 108663: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108666: eb 14 jmp 10867c <== 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 ); 108668: 57 push %edi <== NOT EXECUTED 108669: 6a ff push $0xffffffff <== NOT EXECUTED 10866b: 68 9e a8 13 00 push $0x13a89e <== NOT EXECUTED 108670: ff 35 7c 69 14 00 pushl 0x14697c <== NOT EXECUTED 108676: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED 108679: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } (*print_handler)( 10867c: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10867f: 53 push %ebx <== NOT EXECUTED 108680: 53 push %ebx <== NOT EXECUTED 108681: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 108684: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 108687: 8b 16 mov (%esi),%edx <== NOT EXECUTED 108689: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 10868d: 52 push %edx <== NOT EXECUTED 10868e: 50 push %eax <== NOT EXECUTED 10868f: 68 ac a8 13 00 push $0x13a8ac <== NOT EXECUTED 108694: ff 35 7c 69 14 00 pushl 0x14697c <== NOT EXECUTED 10869a: ff 15 80 69 14 00 call *0x146980 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1086a0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1086a3: 83 3d 78 69 14 00 00 cmpl $0x0,0x146978 <== NOT EXECUTED 1086aa: a1 80 69 14 00 mov 0x146980,%eax <== NOT EXECUTED 1086af: 75 09 jne 1086ba <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 1086b1: 51 push %ecx <== NOT EXECUTED 1086b2: 51 push %ecx <== NOT EXECUTED 1086b3: 68 ca a8 13 00 push $0x13a8ca <== NOT EXECUTED 1086b8: eb 09 jmp 1086c3 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 1086ba: 52 push %edx <== NOT EXECUTED 1086bb: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 1086be: 68 d7 a8 13 00 push $0x13a8d7 <== NOT EXECUTED 1086c3: ff 35 7c 69 14 00 pushl 0x14697c <== NOT EXECUTED 1086c9: ff d0 call *%eax <== NOT EXECUTED 1086cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 1086ce: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1086d1: 5b pop %ebx <== NOT EXECUTED 1086d2: 5e pop %esi <== NOT EXECUTED 1086d3: 5f pop %edi <== NOT EXECUTED 1086d4: c9 leave <== NOT EXECUTED 1086d5: c3 ret <== NOT EXECUTED 00108887 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 108887: 55 push %ebp <== NOT EXECUTED 108888: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10888a: 57 push %edi <== NOT EXECUTED 10888b: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED uint32_t *p; if (Stack_check_Initialized) 10888e: 83 3d 78 69 14 00 00 cmpl $0x0,0x146978 <== NOT EXECUTED 108895: 75 59 jne 1088f0 <== NOT EXECUTED for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ 108897: c7 05 70 9a 15 00 0d movl $0xfeedf00d,0x159a70 <== NOT EXECUTED 10889e: f0 ed fe <== NOT EXECUTED p[1] = 0x0BAD0D06; 1088a1: c7 05 74 9a 15 00 06 movl $0xbad0d06,0x159a74 <== NOT EXECUTED 1088a8: 0d ad 0b <== NOT EXECUTED p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 1088ab: c7 05 78 9a 15 00 0d movl $0xdeadf00d,0x159a78 <== NOT EXECUTED 1088b2: f0 ad de <== NOT EXECUTED p[3] = 0x600D0D06; 1088b5: c7 05 7c 9a 15 00 06 movl $0x600d0d06,0x159a7c <== NOT EXECUTED 1088bc: 0d 0d 60 <== NOT EXECUTED /* * If appropriate, setup the interrupt stack for high water testing * also. */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { 1088bf: 8b 3d 04 9c 15 00 mov 0x159c04,%edi <== NOT EXECUTED 1088c5: 85 ff test %edi,%edi <== NOT EXECUTED 1088c7: 74 1d je 1088e6 <== NOT EXECUTED 1088c9: a1 c4 9b 15 00 mov 0x159bc4,%eax <== NOT EXECUTED 1088ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1088d0: 74 14 je 1088e6 <== NOT EXECUTED Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 1088d2: 89 3d 84 9a 15 00 mov %edi,0x159a84 <== NOT EXECUTED Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 1088d8: 89 c1 mov %eax,%ecx <== NOT EXECUTED 1088da: 29 f9 sub %edi,%ecx <== NOT EXECUTED 1088dc: 89 0d 80 9a 15 00 mov %ecx,0x159a80 <== NOT EXECUTED (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 1088e2: b0 a5 mov $0xa5,%al <== NOT EXECUTED 1088e4: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED } #endif Stack_check_Initialized = 1; 1088e6: c7 05 78 69 14 00 01 movl $0x1,0x146978 <== NOT EXECUTED 1088ed: 00 00 00 <== NOT EXECUTED } 1088f0: 58 pop %eax <== NOT EXECUTED 1088f1: 5f pop %edi <== NOT EXECUTED 1088f2: c9 leave <== NOT EXECUTED 1088f3: c3 ret <== NOT EXECUTED 00108593 : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 108593: 55 push %ebp <== NOT EXECUTED 108594: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108596: 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; 108599: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10859c: 83 c2 10 add $0x10,%edx <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 10859f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 1085a2: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 1085a5: eb 0f jmp 1085b6 <== NOT EXECUTED if (*base != U32_PATTERN) 1085a7: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED 1085ad: 74 04 je 1085b3 <== NOT EXECUTED return (void *) base; 1085af: 89 d0 mov %edx,%eax <== NOT EXECUTED 1085b1: eb 09 jmp 1085bc <== 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++) 1085b3: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 1085b6: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1085b8: 72 ed jb 1085a7 <== NOT EXECUTED 1085ba: 31 c0 xor %eax,%eax <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 1085bc: c9 leave <== NOT EXECUTED 1085bd: c3 ret <== NOT EXECUTED 0010874e : */ void Stack_check_report_blown_task( Thread_Control *running, bool pattern_ok ) { 10874e: 55 push %ebp <== NOT EXECUTED 10874f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108751: 56 push %esi <== NOT EXECUTED 108752: 53 push %ebx <== NOT EXECUTED 108753: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 108756: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; printk( 108759: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 10875c: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 10875f: 56 push %esi <== NOT EXECUTED 108760: 68 3e a9 13 00 push $0x13a93e <== NOT EXECUTED 108765: e8 60 2a 00 00 call 10b1ca <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 10876a: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx <== NOT EXECUTED 108770: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 108776: 50 push %eax <== NOT EXECUTED 108777: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10877b: 50 push %eax <== NOT EXECUTED 10877c: 52 push %edx <== NOT EXECUTED 10877d: 68 7c a9 13 00 push $0x13a97c <== NOT EXECUTED 108782: e8 43 2a 00 00 call 10b1ca <== NOT EXECUTED stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 108787: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10878a: 84 db test %bl,%bl <== NOT EXECUTED 10878c: 75 1a jne 1087a8 <== NOT EXECUTED printk( 10878e: 53 push %ebx <== NOT EXECUTED 10878f: 6a 10 push $0x10 <== NOT EXECUTED 108791: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax <== NOT EXECUTED 108797: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10879a: 50 push %eax <== NOT EXECUTED 10879b: 68 aa a9 13 00 push $0x13a9aa <== NOT EXECUTED 1087a0: e8 25 2a 00 00 call 10b1ca <== NOT EXECUTED 1087a5: 83 c4 10 add $0x10,%esp <== 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 ); 1087a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1087ab: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 1087b0: e8 bf 56 00 00 call 10de74 <== NOT EXECUTED 00109950 <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 109950: 55 push %ebp <== NOT EXECUTED 109951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109953: 57 push %edi <== NOT EXECUTED 109954: 56 push %esi <== NOT EXECUTED 109955: 53 push %ebx <== NOT EXECUTED 109956: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 109959: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10995c: be 48 68 11 00 mov $0x116848,%esi <== NOT EXECUTED 109961: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109966: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 109968: 68 ec ca 11 00 push $0x11caec <== NOT EXECUTED 10996d: e8 4a 08 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 109972: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 109974: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109977: 6a 01 push $0x1 <== NOT EXECUTED 109979: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10997c: 50 push %eax <== NOT EXECUTED 10997d: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 109980: 50 push %eax <== NOT EXECUTED 109981: e8 f6 01 00 00 call 109b7c <_CORE_mutex_Initialize> <== NOT EXECUTED 109986: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10998a: a1 08 cb 11 00 mov 0x11cb08,%eax <== NOT EXECUTED 10998f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109992: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_API_Mutex_Information, &mutex->Object, 1 ); *the_mutex = mutex; 109999: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10999c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10999e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1099a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1099a4: 5b pop %ebx <== NOT EXECUTED 1099a5: 5e pop %esi <== NOT EXECUTED 1099a6: 5f pop %edi <== NOT EXECUTED 1099a7: c9 leave <== NOT EXECUTED 1099a8: c3 ret <== NOT EXECUTED 001099d0 <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 1099d0: 55 push %ebp <== NOT EXECUTED 1099d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 1099d6: 6a 00 push $0x0 <== NOT EXECUTED 1099d8: 6a 00 push $0x0 <== NOT EXECUTED 1099da: 6a 74 push $0x74 <== NOT EXECUTED 1099dc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099df: 6a 02 push $0x2 <== NOT EXECUTED 1099e1: 6a 01 push $0x1 <== NOT EXECUTED 1099e3: 68 ec ca 11 00 push $0x11caec <== NOT EXECUTED 1099e8: e8 6b 0c 00 00 call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 1099ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 1099f0: c9 leave <== NOT EXECUTED 1099f1: c3 ret <== NOT EXECUTED 001099ac <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 1099ac: 55 push %ebp <== NOT EXECUTED 1099ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099af: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1099b2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1099b5: 9c pushf <== NOT EXECUTED 1099b6: fa cli <== NOT EXECUTED 1099b7: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 1099b8: 52 push %edx <== NOT EXECUTED 1099b9: 6a 00 push $0x0 <== NOT EXECUTED 1099bb: 6a 01 push $0x1 <== NOT EXECUTED 1099bd: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1099c0: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1099c3: 50 push %eax <== NOT EXECUTED 1099c4: e8 9f 02 00 00 call 109c68 <_CORE_mutex_Seize> <== NOT EXECUTED 1099c9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 1099cc: c9 leave <== NOT EXECUTED 1099cd: c3 ret <== NOT EXECUTED 001099f4 <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 1099f4: 55 push %ebp <== NOT EXECUTED 1099f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099fa: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1099fd: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109a02: 40 inc %eax <== NOT EXECUTED 109a03: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 109a08: 6a 00 push $0x0 <== NOT EXECUTED 109a0a: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 109a0d: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 109a10: 52 push %edx <== NOT EXECUTED 109a11: e8 e2 02 00 00 call 109cf8 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109a16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109a19: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109a1a: e9 a1 13 00 00 jmp 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 00109936 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 109936: 55 push %ebp <== NOT EXECUTED 109937: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109939: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10993c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10993f: 68 24 cc 11 00 push $0x11cc24 <== NOT EXECUTED 109944: e8 d7 00 00 00 call 109a20 <_Chain_Append> <== NOT EXECUTED 109949: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10994c: c9 leave <== NOT EXECUTED 10994d: c3 ret <== NOT EXECUTED 00109894 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 109894: 55 push %ebp <== NOT EXECUTED 109895: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109897: c7 05 24 cc 11 00 28 movl $0x11cc28,0x11cc24 <== NOT EXECUTED 10989e: cc 11 00 <== NOT EXECUTED 1098a1: c7 05 28 cc 11 00 00 movl $0x0,0x11cc28 <== NOT EXECUTED 1098a8: 00 00 00 <== NOT EXECUTED 1098ab: c7 05 2c cc 11 00 24 movl $0x11cc24,0x11cc2c <== NOT EXECUTED 1098b2: cc 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 1098b5: c9 leave <== NOT EXECUTED 1098b6: c3 ret <== NOT EXECUTED 001098dd <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 1098dd: 55 push %ebp <== NOT EXECUTED 1098de: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098e0: 53 push %ebx <== NOT EXECUTED 1098e1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1098e4: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 1098ea: eb 0b jmp 1098f7 <_API_extensions_Run_postdriver+0x1a> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 1098ec: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1098ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1098f1: 74 02 je 1098f5 <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 1098f3: 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 ) { 1098f5: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1098f7: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 1098fd: 75 ed jne 1098ec <_API_extensions_Run_postdriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 1098ff: 5a pop %edx <== NOT EXECUTED 109900: 5b pop %ebx <== NOT EXECUTED 109901: c9 leave <== NOT EXECUTED 109902: c3 ret <== NOT EXECUTED 00109903 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 109903: 55 push %ebp <== NOT EXECUTED 109904: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109906: 53 push %ebx <== NOT EXECUTED 109907: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10990a: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 109910: eb 17 jmp 109929 <_API_extensions_Run_postswitch+0x26> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 109912: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 109915: 85 c0 test %eax,%eax <== NOT EXECUTED 109917: 74 0e je 109927 <_API_extensions_Run_postswitch+0x24> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 109919: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10991c: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 109922: ff d0 call *%eax <== NOT EXECUTED 109924: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 109927: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 109929: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 10992f: 75 e1 jne 109912 <_API_extensions_Run_postswitch+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 109931: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109934: c9 leave <== NOT EXECUTED 109935: c3 ret <== NOT EXECUTED 001098b7 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 1098b7: 55 push %ebp <== NOT EXECUTED 1098b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098ba: 53 push %ebx <== NOT EXECUTED 1098bb: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1098be: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 1098c4: eb 0b jmp 1098d1 <_API_extensions_Run_predriver+0x1a> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 1098c6: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1098c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1098cb: 74 02 je 1098cf <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED (*the_extension->predriver_hook)(); 1098cd: 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 ) { 1098cf: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1098d1: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 1098d7: 75 ed jne 1098c6 <_API_extensions_Run_predriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 1098d9: 58 pop %eax <== NOT EXECUTED 1098da: 5b pop %ebx <== NOT EXECUTED 1098db: c9 leave <== NOT EXECUTED 1098dc: c3 ret <== NOT EXECUTED 0010d248 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10d248: 55 push %ebp <== NOT EXECUTED 10d249: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d24b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d24e: 6a 04 push $0x4 <== NOT EXECUTED 10d250: 6a 00 push $0x0 <== NOT EXECUTED 10d252: 6a 60 push $0x60 <== NOT EXECUTED 10d254: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d257: 6a 0a push $0xa <== NOT EXECUTED 10d259: 6a 02 push $0x2 <== NOT EXECUTED 10d25b: 68 34 cd 11 00 push $0x11cd34 <== NOT EXECUTED 10d260: e8 f3 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d265: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d268: c9 leave <== NOT EXECUTED 10d269: c3 ret <== NOT EXECUTED 0010e194 <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 10e194: 55 push %ebp <== NOT EXECUTED 10e195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e197: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e19a: 8b 04 85 d0 d3 11 00 mov 0x11d3d0(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Barrier_Translate_core_barrier_return_code_[the_barrier_status]; } 10e1a1: c9 leave <== NOT EXECUTED 10e1a2: c3 ret <== NOT EXECUTED 0010a834 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10a834: 55 push %ebp <== NOT EXECUTED 10a835: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a837: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a83a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a83d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10a840: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10a842: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a845: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10a848: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10a84b: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10a852: 6a 03 push $0x3 <== NOT EXECUTED 10a854: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10a859: 6a 00 push $0x0 <== NOT EXECUTED 10a85b: 52 push %edx <== NOT EXECUTED 10a85c: e8 8f 1a 00 00 call 10c2f0 <_Thread_queue_Initialize> <== NOT EXECUTED 10a861: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10a864: c9 leave <== NOT EXECUTED 10a865: c3 ret <== NOT EXECUTED 0010a868 <_CORE_barrier_Release>: uint32_t _CORE_barrier_Release( CORE_barrier_Control *the_barrier, Objects_Id id, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10a868: 55 push %ebp <== NOT EXECUTED 10a869: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a86b: 56 push %esi <== NOT EXECUTED 10a86c: 53 push %ebx <== NOT EXECUTED 10a86d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10a870: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a872: eb 01 jmp 10a875 <_CORE_barrier_Release+0xd> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; 10a874: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10a875: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a878: 56 push %esi <== NOT EXECUTED 10a879: e8 26 17 00 00 call 10bfa4 <_Thread_queue_Dequeue> <== NOT EXECUTED 10a87e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a881: 85 c0 test %eax,%eax <== NOT EXECUTED 10a883: 75 ef jne 10a874 <_CORE_barrier_Release+0xc> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; } the_barrier->number_of_waiting_threads = 0; 10a885: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 10a88c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a88e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a891: 5b pop %ebx <== NOT EXECUTED 10a892: 5e pop %esi <== NOT EXECUTED 10a893: c9 leave <== NOT EXECUTED 10a894: c3 ret <== NOT EXECUTED 0010a898 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10a898: 55 push %ebp <== NOT EXECUTED 10a899: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a89b: 57 push %edi <== NOT EXECUTED 10a89c: 56 push %esi <== NOT EXECUTED 10a89d: 53 push %ebx <== NOT EXECUTED 10a89e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a8a1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a8a4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a8a7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a8aa: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10a8ad: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10a8b0: 8b 0d b4 f5 11 00 mov 0x11f5b4,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10a8b6: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10a8bd: 9c pushf <== NOT EXECUTED 10a8be: fa cli <== NOT EXECUTED 10a8bf: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10a8c0: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10a8c3: 40 inc %eax <== NOT EXECUTED 10a8c4: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10a8c7: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10a8ca: 75 22 jne 10a8ee <_CORE_barrier_Wait+0x56> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10a8cc: 83 7a 40 00 cmpl $0x0,0x40(%edx) <== NOT EXECUTED 10a8d0: 75 1c jne 10a8ee <_CORE_barrier_Wait+0x56> <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 10a8d2: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10a8d9: 53 push %ebx <== NOT EXECUTED 10a8da: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10a8db: 89 7d 10 mov %edi,0x10(%ebp) <== NOT EXECUTED 10a8de: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10a8e1: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 10a8e4: 5a pop %edx <== NOT EXECUTED 10a8e5: 5b pop %ebx <== NOT EXECUTED 10a8e6: 5e pop %esi <== NOT EXECUTED 10a8e7: 5f pop %edi <== NOT EXECUTED 10a8e8: c9 leave <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; _ISR_Enable( level ); _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10a8e9: e9 7a ff ff ff jmp 10a868 <_CORE_barrier_Release> <== 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 10a8ee: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 10a8f5: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10a8f8: 89 71 20 mov %esi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10a8fb: 53 push %ebx <== NOT EXECUTED 10a8fc: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10a8fd: c7 45 10 c0 c3 10 00 movl $0x10c3c0,0x10(%ebp) <== NOT EXECUTED 10a904: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a907: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10a90a: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10a90d: 58 pop %eax <== NOT EXECUTED 10a90e: 5b pop %ebx <== NOT EXECUTED 10a90f: 5e pop %esi <== NOT EXECUTED 10a910: 5f pop %edi <== NOT EXECUTED 10a911: c9 leave <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10a912: e9 a5 17 00 00 jmp 10c0bc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00113a3c <_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 ) { 113a3c: 55 push %ebp <== NOT EXECUTED 113a3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a3f: 57 push %edi <== NOT EXECUTED 113a40: 56 push %esi <== NOT EXECUTED 113a41: 53 push %ebx <== NOT EXECUTED 113a42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 113a45: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 113a4a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113a4d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 113a50: 3b 4a 4c cmp 0x4c(%edx),%ecx <== NOT EXECUTED 113a53: 77 43 ja 113a98 <_CORE_message_queue_Broadcast+0x5c> <== NOT EXECUTED * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113a55: 31 db xor %ebx,%ebx <== NOT EXECUTED * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 113a57: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 113a5a: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 113a5e: 74 21 je 113a81 <_CORE_message_queue_Broadcast+0x45> <== NOT EXECUTED *count = 0; 113a60: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 113a63: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 113a69: 31 c0 xor %eax,%eax <== NOT EXECUTED 113a6b: eb 2b jmp 113a98 <_CORE_message_queue_Broadcast+0x5c> <== NOT EXECUTED */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 113a6d: 43 inc %ebx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 113a6e: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 113a71: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 113a74: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113a77: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 113a79: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 113a7c: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 113a7f: 89 10 mov %edx,(%eax) <== NOT EXECUTED * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113a81: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113a84: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113a87: e8 98 1f 00 00 call 115a24 <_Thread_queue_Dequeue> <== NOT EXECUTED 113a8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113a8f: 85 c0 test %eax,%eax <== NOT EXECUTED 113a91: 75 da jne 113a6d <_CORE_message_queue_Broadcast+0x31> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 113a93: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 113a96: 89 19 mov %ebx,(%ecx) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 113a98: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113a9b: 5b pop %ebx <== NOT EXECUTED 113a9c: 5e pop %esi <== NOT EXECUTED 113a9d: 5f pop %edi <== NOT EXECUTED 113a9e: c9 leave <== NOT EXECUTED 113a9f: c3 ret <== NOT EXECUTED 0011294c <_CORE_message_queue_Close>: void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 11294c: 55 push %ebp <== NOT EXECUTED 11294d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11294f: 53 push %ebx <== NOT EXECUTED 112950: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112953: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * This will flush blocked threads whether they were blocked on * a send or receive. */ _Thread_queue_Flush( 112956: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112959: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11295c: 53 push %ebx <== NOT EXECUTED 11295d: e8 62 c1 ff ff call 10eac4 <_Thread_queue_Flush> <== NOT EXECUTED * This removes all messages from the pending message queue. Since * we just flushed all waiting threads, we don't have to worry about * the flush satisfying any blocked senders as a side-effect. */ if ( the_message_queue->number_of_pending_messages != 0 ) 112962: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112965: 83 7b 48 00 cmpl $0x0,0x48(%ebx) <== NOT EXECUTED 112969: 74 0c je 112977 <_CORE_message_queue_Close+0x2b> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 11296b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11296e: 53 push %ebx <== NOT EXECUTED 11296f: e8 14 00 00 00 call 112988 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 112974: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 112977: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 11297a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11297d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112980: c9 leave <== NOT EXECUTED */ if ( the_message_queue->number_of_pending_messages != 0 ) (void) _CORE_message_queue_Flush_support( the_message_queue ); (void) _Workspace_Free( the_message_queue->message_buffers ); 112981: e9 f6 ca ff ff jmp 10f47c <_Workspace_Free> <== NOT EXECUTED 00113adc <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 113adc: 55 push %ebp <== NOT EXECUTED 113add: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113adf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 113ae2: 83 78 48 00 cmpl $0x0,0x48(%eax) <== NOT EXECUTED 113ae6: 75 04 jne 113aec <_CORE_message_queue_Flush+0x10> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 113ae8: 31 c0 xor %eax,%eax <== NOT EXECUTED 113aea: c9 leave <== NOT EXECUTED 113aeb: c3 ret <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 113aec: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 113aef: c9 leave <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 113af0: e9 03 00 00 00 jmp 113af8 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00112988 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 112988: 55 push %ebp <== NOT EXECUTED 112989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11298b: 56 push %esi <== NOT EXECUTED 11298c: 53 push %ebx <== NOT EXECUTED 11298d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED * * For now, though, we are very happy to have a small routine with * fixed execution time that only deals with pending messages. */ _ISR_Disable( level ); 112990: 9c pushf <== NOT EXECUTED 112991: fa cli <== NOT EXECUTED 112992: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 112993: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 112996: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 112999: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 11299c: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 11299f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 1129a1: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 1129a4: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 1129a7: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 1129aa: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 1129ad: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 1129b0: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 1129b7: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 1129ba: 89 42 58 mov %eax,0x58(%edx) <== NOT EXECUTED _Chain_Head( &the_message_queue->Inactive_messages ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); count = the_message_queue->number_of_pending_messages; 1129bd: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 1129c0: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 1129c7: 56 push %esi <== NOT EXECUTED 1129c8: 9d popf <== NOT EXECUTED return count; } 1129c9: 5b pop %ebx <== NOT EXECUTED 1129ca: 5e pop %esi <== NOT EXECUTED 1129cb: c9 leave <== NOT EXECUTED 1129cc: c3 ret <== NOT EXECUTED 0010e21c <_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 ) { 10e21c: 55 push %ebp <== NOT EXECUTED 10e21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e21f: 57 push %edi <== NOT EXECUTED 10e220: 56 push %esi <== NOT EXECUTED 10e221: 53 push %ebx <== NOT EXECUTED 10e222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e225: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e228: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10e22b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 10e22e: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10e231: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10e238: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10e23b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10e242: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 10e249: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e24b: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10e24e: 74 0a je 10e25a <_CORE_message_queue_Initialize+0x3e> <== NOT EXECUTED allocated_message_size += sizeof(uint32_t); 10e250: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10e253: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10e256: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10e258: 72 5f jb 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 10e25a: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10e25d: 89 f2 mov %esi,%edx <== NOT EXECUTED 10e25f: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10e262: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10e264: 72 53 jb 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10e266: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e269: 52 push %edx <== NOT EXECUTED 10e26a: e8 6e 26 00 00 call 1108dd <_Workspace_Allocate> <== NOT EXECUTED 10e26f: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10e272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e275: 85 c0 test %eax,%eax <== NOT EXECUTED 10e277: 74 40 je 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10e279: 56 push %esi <== NOT EXECUTED 10e27a: 57 push %edi <== NOT EXECUTED 10e27b: 50 push %eax <== NOT EXECUTED 10e27c: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10e27f: 50 push %eax <== NOT EXECUTED 10e280: e8 7b 34 01 00 call 121700 <_Chain_Initialize> <== NOT EXECUTED 10e285: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10e288: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e28b: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10e292: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10e295: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 10e298: 6a 06 push $0x6 <== NOT EXECUTED 10e29a: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10e29f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e2a2: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10e2a5: 0f 94 c0 sete %al <== NOT EXECUTED 10e2a8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10e2ab: 50 push %eax <== NOT EXECUTED 10e2ac: 53 push %ebx <== NOT EXECUTED 10e2ad: e8 12 1d 00 00 call 10ffc4 <_Thread_queue_Initialize> <== NOT EXECUTED 10e2b2: b0 01 mov $0x1,%al <== NOT EXECUTED 10e2b4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e2b7: eb 02 jmp 10e2bb <_CORE_message_queue_Initialize+0x9f> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10e2b9: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10e2bb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e2be: 5b pop %ebx <== NOT EXECUTED 10e2bf: 5e pop %esi <== NOT EXECUTED 10e2c0: 5f pop %edi <== NOT EXECUTED 10e2c1: c9 leave <== NOT EXECUTED 10e2c2: c3 ret <== NOT EXECUTED 0010d6a0 <_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 ) { 10d6a0: 55 push %ebp <== NOT EXECUTED 10d6a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d6a3: 57 push %edi <== NOT EXECUTED 10d6a4: 56 push %esi <== NOT EXECUTED 10d6a5: 53 push %ebx <== NOT EXECUTED 10d6a6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d6a9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d6ac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d6af: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10d6b2: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED switch ( submit_type ) { 10d6b5: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10d6ba: 74 33 je 10d6ef <_CORE_message_queue_Insert_message+0x4f> <== NOT EXECUTED 10d6bc: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10d6c1: 8d 53 54 lea 0x54(%ebx),%edx <== NOT EXECUTED 10d6c4: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 10d6c7: 75 4d jne 10d716 <_CORE_message_queue_Insert_message+0x76> <== NOT EXECUTED case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10d6c9: 9c pushf <== NOT EXECUTED 10d6ca: fa cli <== NOT EXECUTED 10d6cb: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d6cc: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d6cf: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d6d2: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d6d5: 85 d2 test %edx,%edx <== NOT EXECUTED 10d6d7: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10d6db: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d6de: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d6e0: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10d6e3: 89 73 58 mov %esi,0x58(%ebx) <== NOT EXECUTED 10d6e6: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d6e8: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10d6eb: 51 push %ecx <== NOT EXECUTED 10d6ec: 9d popf <== NOT EXECUTED 10d6ed: eb 5b jmp 10d74a <_CORE_message_queue_Insert_message+0xaa> <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10d6ef: 9c pushf <== NOT EXECUTED 10d6f0: fa cli <== NOT EXECUTED 10d6f1: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d6f2: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d6f5: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d6f8: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d6fb: 85 d2 test %edx,%edx <== NOT EXECUTED 10d6fd: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10d701: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10d704: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d707: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10d70a: 89 73 50 mov %esi,0x50(%ebx) <== NOT EXECUTED 10d70d: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d70f: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10d712: 51 push %ecx <== NOT EXECUTED 10d713: 9d popf <== NOT EXECUTED 10d714: eb 34 jmp 10d74a <_CORE_message_queue_Insert_message+0xaa> <== NOT EXECUTED CORE_message_queue_Buffer_control *this_message; Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; 10d716: 8b 7b 50 mov 0x50(%ebx),%edi <== NOT EXECUTED 10d719: eb 07 jmp 10d722 <_CORE_message_queue_Insert_message+0x82> <== 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 ) { 10d71b: 39 47 08 cmp %eax,0x8(%edi) <== NOT EXECUTED 10d71e: 7f 07 jg 10d727 <_CORE_message_queue_Insert_message+0x87> <== NOT EXECUTED the_node = the_node->next; 10d720: 8b 3f mov (%edi),%edi <== 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 ) ) { 10d722: 3b 7d ec cmp -0x14(%ebp),%edi <== NOT EXECUTED 10d725: 75 f4 jne 10d71b <_CORE_message_queue_Insert_message+0x7b> <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10d727: 9c pushf <== NOT EXECUTED 10d728: fa cli <== NOT EXECUTED 10d729: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d72a: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d72d: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d730: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d733: 85 d2 test %edx,%edx <== NOT EXECUTED 10d735: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10d739: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10d73c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d73f: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d741: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d743: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d745: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10d748: 51 push %ecx <== NOT EXECUTED 10d749: 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 ) 10d74a: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d74e: 74 15 je 10d765 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED 10d750: 8b 4b 60 mov 0x60(%ebx),%ecx <== NOT EXECUTED 10d753: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d755: 74 0e je 10d765 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10d757: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 10d75a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10d75d: 5b pop %ebx <== NOT EXECUTED 10d75e: 5e pop %esi <== NOT EXECUTED 10d75f: 5b pop %ebx <== NOT EXECUTED 10d760: 5e pop %esi <== NOT EXECUTED 10d761: 5f pop %edi <== NOT EXECUTED 10d762: 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 ); 10d763: ff e1 jmp *%ecx <== NOT EXECUTED } 10d765: 58 pop %eax <== NOT EXECUTED 10d766: 5a pop %edx <== NOT EXECUTED 10d767: 5b pop %ebx <== NOT EXECUTED 10d768: 5e pop %esi <== NOT EXECUTED 10d769: 5f pop %edi <== NOT EXECUTED 10d76a: c9 leave <== NOT EXECUTED 10d76b: c3 ret <== NOT EXECUTED 00112a9c <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 112a9c: 55 push %ebp <== NOT EXECUTED 112a9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112a9f: 57 push %edi <== NOT EXECUTED 112aa0: 56 push %esi <== NOT EXECUTED 112aa1: 53 push %ebx <== NOT EXECUTED 112aa2: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 112aa5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112aa8: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 112aab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 112aae: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 112ab1: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 112ab4: 89 7d e8 mov %edi,-0x18(%ebp) <== NOT EXECUTED 112ab7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112aba: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 112abd: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 112ac0: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 112ac3: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 112ac6: 88 45 e3 mov %al,-0x1d(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 112ac9: 8b 35 44 89 12 00 mov 0x128944,%esi <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112acf: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Disable( level ); 112ad6: 9c pushf <== NOT EXECUTED 112ad7: fa cli <== NOT EXECUTED 112ad8: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 112ad9: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 112adc: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 112adf: 89 d0 mov %edx,%eax <== NOT EXECUTED 112ae1: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 112ae4: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 112ae6: 0f 84 9e 00 00 00 je 112b8a <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED 112aec: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 112aee: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 112af1: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 112af4: 89 f8 mov %edi,%eax <== NOT EXECUTED 112af6: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 112af9: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 112afc: 85 db test %ebx,%ebx <== NOT EXECUTED 112afe: 0f 84 86 00 00 00 je 112b8a <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED the_message_queue->number_of_pending_messages -= 1; 112b04: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 112b07: 51 push %ecx <== NOT EXECUTED 112b08: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 112b09: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 112b0c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 112b0f: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 112b11: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 112b14: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112b19: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 112b1c: 8d 7b 10 lea 0x10(%ebx),%edi <== NOT EXECUTED 112b1f: 89 7d f0 mov %edi,-0x10(%ebp) <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 112b22: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 112b25: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 112b27: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 112b2a: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 112b2d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 112b2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112b32: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 112b35: e8 66 bc ff ff call 10e7a0 <_Thread_queue_Dequeue> <== NOT EXECUTED 112b3a: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 112b3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b3f: 85 c0 test %eax,%eax <== NOT EXECUTED 112b41: 75 18 jne 112b5b <_CORE_message_queue_Seize+0xbf> <== NOT EXECUTED * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 112b43: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 112b46: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112b49: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 112b4c: 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 ); } 112b4f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b52: 5b pop %ebx <== NOT EXECUTED 112b53: 5e pop %esi <== NOT EXECUTED 112b54: 5f pop %edi <== NOT EXECUTED 112b55: c9 leave <== NOT EXECUTED 112b56: e9 41 a5 ff ff jmp 10d09c <_Chain_Append> <== NOT EXECUTED * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 112b5b: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 112b5e: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 112b61: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 112b64: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 112b67: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 112b6a: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 112b6d: 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( 112b6f: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 112b72: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 112b75: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 112b78: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112b7b: 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 ); } 112b7e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b81: 5b pop %ebx <== NOT EXECUTED 112b82: 5e pop %esi <== NOT EXECUTED 112b83: 5f pop %edi <== NOT EXECUTED 112b84: 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( 112b85: e9 46 fe ff ff jmp 1129d0 <_CORE_message_queue_Insert_message> <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 112b8a: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) <== NOT EXECUTED 112b8e: 75 11 jne 112ba1 <_CORE_message_queue_Seize+0x105> <== NOT EXECUTED _ISR_Enable( level ); 112b90: 51 push %ecx <== NOT EXECUTED 112b91: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 112b92: c7 46 34 04 00 00 00 movl $0x4,0x34(%esi) <== 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 ); } 112b99: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b9c: 5b pop %ebx <== NOT EXECUTED 112b9d: 5e pop %esi <== NOT EXECUTED 112b9e: 5f pop %edi <== NOT EXECUTED 112b9f: c9 leave <== NOT EXECUTED 112ba0: c3 ret <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 112ba1: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 112ba4: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 112bab: 89 56 44 mov %edx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 112bae: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 112bb1: 89 7e 20 mov %edi,0x20(%esi) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 112bb4: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 112bb7: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED executing->Wait.return_argument = size_p; 112bba: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 112bbd: 89 56 28 mov %edx,0x28(%esi) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 112bc0: 51 push %ecx <== NOT EXECUTED 112bc1: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 112bc2: c7 45 10 bc eb 10 00 movl $0x10ebbc,0x10(%ebp) <== NOT EXECUTED 112bc9: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 112bcc: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 112bcf: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112bd2: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 112bd5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112bd8: 5b pop %ebx <== NOT EXECUTED 112bd9: 5e pop %esi <== NOT EXECUTED 112bda: 5f pop %edi <== NOT EXECUTED 112bdb: c9 leave <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 112bdc: e9 d7 bc ff ff jmp 10e8b8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00109a6c <_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 ) { 109a6c: 55 push %ebp <== NOT EXECUTED 109a6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a6f: 57 push %edi <== NOT EXECUTED 109a70: 56 push %esi <== NOT EXECUTED 109a71: 53 push %ebx <== NOT EXECUTED 109a72: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109a75: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 109a78: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 109a7b: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 109a7e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 109a83: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109a86: 3b 5a 4c cmp 0x4c(%edx),%ebx <== NOT EXECUTED 109a89: 0f 87 d9 00 00 00 ja 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 109a8f: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109a92: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 109a96: 75 2e jne 109ac6 <_CORE_message_queue_Submit+0x5a> <== NOT EXECUTED the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 109a98: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a9b: 56 push %esi <== NOT EXECUTED 109a9c: e8 57 16 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109aa1: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 109aa3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109aa6: 85 c0 test %eax,%eax <== NOT EXECUTED 109aa8: 74 1c je 109ac6 <_CORE_message_queue_Submit+0x5a> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109aaa: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 109aad: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109ab0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109ab2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 109ab4: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 109ab7: 89 18 mov %ebx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 109ab9: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 109abc: 89 42 24 mov %eax,0x24(%edx) <== NOT EXECUTED 109abf: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ac1: e9 a2 00 00 00 jmp 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 109ac6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109ac9: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 109acc: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 109acf: 73 37 jae 109b08 <_CORE_message_queue_Submit+0x9c> <== 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. 109ad1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ad4: 89 d0 mov %edx,%eax <== NOT EXECUTED 109ad6: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 109ad9: 50 push %eax <== NOT EXECUTED 109ada: e8 65 ff ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 109adf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ae2: 85 c0 test %eax,%eax <== NOT EXECUTED 109ae4: 74 7d je 109b63 <_CORE_message_queue_Submit+0xf7> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109ae6: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 109ae9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109aec: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109aee: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 109af0: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 109af3: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 109af6: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 109af9: 51 push %ecx <== NOT EXECUTED 109afa: 52 push %edx <== NOT EXECUTED 109afb: 50 push %eax <== NOT EXECUTED 109afc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109aff: e8 9c 3b 00 00 call 10d6a0 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 109b04: 31 c0 xor %eax,%eax <== NOT EXECUTED 109b06: eb 56 jmp 109b5e <_CORE_message_queue_Submit+0xf2> <== NOT EXECUTED * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 109b08: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109b0d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 109b11: 74 55 je 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 109b13: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 109b18: 85 c0 test %eax,%eax <== NOT EXECUTED 109b1a: 75 47 jne 109b63 <_CORE_message_queue_Submit+0xf7> <== 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; 109b1c: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED _ISR_Disable( level ); 109b21: 9c pushf <== NOT EXECUTED 109b22: fa cli <== NOT EXECUTED 109b23: 59 pop %ecx <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109b24: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109b27: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 109b2e: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 109b31: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 109b34: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 109b37: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 109b3a: 89 50 2c mov %edx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 109b3d: 89 58 30 mov %ebx,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 109b40: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 109b43: 89 70 24 mov %esi,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 109b46: 51 push %ecx <== NOT EXECUTED 109b47: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 109b48: 50 push %eax <== NOT EXECUTED 109b49: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109b4e: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 109b51: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109b54: e8 b7 16 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 109b59: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 109b5e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b61: eb 05 jmp 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 109b63: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 109b68: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109b6b: 5b pop %ebx <== NOT EXECUTED 109b6c: 5e pop %esi <== NOT EXECUTED 109b6d: 5f pop %edi <== NOT EXECUTED 109b6e: c9 leave <== NOT EXECUTED 109b6f: c3 ret <== NOT EXECUTED 00109b70 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109b70: 55 push %ebp <== NOT EXECUTED 109b71: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 109b73: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109b74: e9 a3 18 00 00 jmp 10b41c <_Thread_queue_Flush> <== NOT EXECUTED 00109b7c <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 109b7c: 55 push %ebp <== NOT EXECUTED 109b7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b7f: 57 push %edi <== NOT EXECUTED 109b80: 56 push %esi <== NOT EXECUTED 109b81: 53 push %ebx <== NOT EXECUTED 109b82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b85: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109b88: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 109b8b: 8d 7b 40 lea 0x40(%ebx),%edi <== NOT EXECUTED 109b8e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109b93: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109b96: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 109b98: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_mutex->blocked_count = 0; 109b9b: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 109ba2: 85 c0 test %eax,%eax <== NOT EXECUTED 109ba4: 75 35 jne 109bdb <_CORE_mutex_Initialize+0x5f> <== NOT EXECUTED the_mutex->nest_count = 1; 109ba6: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 109bad: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED 109bb3: 89 53 5c mov %edx,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 109bb6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 109bb9: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109bbc: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109bbf: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109bc2: 74 05 je 109bc9 <_CORE_mutex_Initialize+0x4d> <== NOT EXECUTED 109bc4: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109bc7: 75 27 jne 109bf0 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 109bc9: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 109bcc: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 109bd1: 3b 43 4c cmp 0x4c(%ebx),%eax <== NOT EXECUTED 109bd4: 72 3a jb 109c10 <_CORE_mutex_Initialize+0x94> <== NOT EXECUTED _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 109bd6: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109bd9: eb 15 jmp 109bf0 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 109bdb: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = NULL; 109be2: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109be9: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED } _Thread_queue_Initialize( 109bf0: 6a 05 push $0x5 <== NOT EXECUTED 109bf2: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 109bf7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109bfa: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED 109bfe: 0f 95 c0 setne %al <== NOT EXECUTED 109c01: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109c04: 50 push %eax <== NOT EXECUTED 109c05: 53 push %ebx <== NOT EXECUTED 109c06: e8 39 18 00 00 call 10b444 <_Thread_queue_Initialize> <== NOT EXECUTED 109c0b: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 109c0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 109c10: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109c12: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109c15: 5b pop %ebx <== NOT EXECUTED 109c16: 5e pop %esi <== NOT EXECUTED 109c17: 5f pop %edi <== NOT EXECUTED 109c18: c9 leave <== NOT EXECUTED 109c19: c3 ret <== NOT EXECUTED 00109c68 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 109c68: 55 push %ebp <== NOT EXECUTED 109c69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c6b: 56 push %esi <== NOT EXECUTED 109c6c: 53 push %ebx <== NOT EXECUTED 109c6d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109c70: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 109c73: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109c78: 85 c0 test %eax,%eax <== NOT EXECUTED 109c7a: 74 19 je 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c7c: 84 db test %bl,%bl <== NOT EXECUTED 109c7e: 74 15 je 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c80: 83 3d a0 cb 11 00 01 cmpl $0x1,0x11cba0 <== NOT EXECUTED 109c87: 76 0c jbe 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c89: 50 push %eax <== NOT EXECUTED 109c8a: 6a 13 push $0x13 <== NOT EXECUTED 109c8c: 6a 00 push $0x0 <== NOT EXECUTED 109c8e: 6a 00 push $0x0 <== NOT EXECUTED 109c90: e8 93 04 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 109c95: 50 push %eax <== NOT EXECUTED 109c96: 50 push %eax <== NOT EXECUTED 109c97: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 109c9a: 50 push %eax <== NOT EXECUTED 109c9b: 56 push %esi <== NOT EXECUTED 109c9c: e8 cb 3a 00 00 call 10d76c <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 109ca1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ca4: 85 c0 test %eax,%eax <== NOT EXECUTED 109ca6: 74 49 je 109cf1 <_CORE_mutex_Seize+0x89> <== NOT EXECUTED 109ca8: 84 db test %bl,%bl <== NOT EXECUTED 109caa: 75 12 jne 109cbe <_CORE_mutex_Seize+0x56> <== NOT EXECUTED 109cac: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109caf: 9d popf <== NOT EXECUTED 109cb0: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 109cb5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED 109cbc: eb 33 jmp 109cf1 <_CORE_mutex_Seize+0x89> <== 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 109cbe: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 109cc5: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED 109ccb: 89 72 44 mov %esi,0x44(%edx) <== NOT EXECUTED 109cce: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109cd1: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109cd4: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109cd9: 40 inc %eax <== NOT EXECUTED 109cda: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 109cdf: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109ce2: 9d popf <== NOT EXECUTED 109ce3: 53 push %ebx <== NOT EXECUTED 109ce4: 53 push %ebx <== NOT EXECUTED 109ce5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 109ce8: 56 push %esi <== NOT EXECUTED 109ce9: e8 2e ff ff ff call 109c1c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 109cee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109cf1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109cf4: 5b pop %ebx <== NOT EXECUTED 109cf5: 5e pop %esi <== NOT EXECUTED 109cf6: c9 leave <== NOT EXECUTED 109cf7: c3 ret <== NOT EXECUTED 00109c1c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 109c1c: 55 push %ebp <== NOT EXECUTED 109c1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c1f: 56 push %esi <== NOT EXECUTED 109c20: 53 push %ebx <== NOT EXECUTED 109c21: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109c24: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 109c27: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 109c2c: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 109c30: 75 18 jne 109c4a <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED if ( the_mutex->holder->current_priority > executing->current_priority ) { 109c32: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 109c35: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 109c38: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 109c3b: 76 0d jbe 109c4a <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED _Thread_Change_priority( 109c3d: 51 push %ecx <== NOT EXECUTED 109c3e: 6a 00 push $0x0 <== NOT EXECUTED 109c40: 50 push %eax <== NOT EXECUTED 109c41: 52 push %edx <== NOT EXECUTED 109c42: e8 d9 0c 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109c47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 109c4a: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 109c4d: 50 push %eax <== NOT EXECUTED 109c4e: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109c53: 56 push %esi <== NOT EXECUTED 109c54: 53 push %ebx <== NOT EXECUTED 109c55: e8 b6 15 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 109c5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109c5d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c60: 5b pop %ebx <== NOT EXECUTED 109c61: 5e pop %esi <== NOT EXECUTED 109c62: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 109c63: e9 58 11 00 00 jmp 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010d76c <_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 ) { 10d76c: 55 push %ebp <== NOT EXECUTED 10d76d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d76f: 56 push %esi <== NOT EXECUTED 10d770: 53 push %ebx <== NOT EXECUTED 10d771: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ); 10d774: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d777: 8b 30 mov (%eax),%esi <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10d779: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d77f: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10d786: 83 79 50 00 cmpl $0x0,0x50(%ecx) <== NOT EXECUTED 10d78a: 0f 84 82 00 00 00 je 10d812 <_CORE_mutex_Seize_interrupt_trylock+0xa6> <== NOT EXECUTED * to be resized 10d790: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10d797: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10d79a: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10d79d: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10d7a0: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10d7a7: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to be resized * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. 10d7aa: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d7ad: 74 05 je 10d7b4 <_CORE_mutex_Seize_interrupt_trylock+0x48> <== NOT EXECUTED 10d7af: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10d7b2: 75 03 jne 10d7b7 <_CORE_mutex_Seize_interrupt_trylock+0x4b> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10d7b4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * 10d7b7: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10d7bb: 74 04 je 10d7c1 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d7bd: 56 push %esi <== NOT EXECUTED 10d7be: 9d popf <== NOT EXECUTED 10d7bf: eb 74 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10d7c1: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d7c4: 3b 41 4c cmp 0x4c(%ecx),%eax <== NOT EXECUTED 10d7c7: 75 04 jne 10d7cd <_CORE_mutex_Seize_interrupt_trylock+0x61> <== NOT EXECUTED * @param[in] source is a user specified integer which may be used to 10d7c9: 56 push %esi <== NOT EXECUTED 10d7ca: 9d popf <== NOT EXECUTED 10d7cb: eb 68 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== 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. */ 10d7cd: 76 27 jbe 10d7f6 <_CORE_mutex_Seize_interrupt_trylock+0x8a> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d7cf: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10d7d4: 40 inc %eax <== NOT EXECUTED 10d7d5: a3 00 ca 11 00 mov %eax,0x11ca00 <== 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, 10d7da: 56 push %esi <== NOT EXECUTED 10d7db: 9d popf <== NOT EXECUTED int source, 10d7dc: 50 push %eax <== NOT EXECUTED 10d7dd: 6a 00 push $0x0 <== NOT EXECUTED 10d7df: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10d7e2: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10d7e5: e8 36 d1 ff ff call 10a920 <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10d7ea: e8 d1 d5 ff ff call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d7ef: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d7f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7f4: eb 48 jmp 10d83e <_CORE_mutex_Seize_interrupt_trylock+0xd2> <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area 10d7f6: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10d7fd: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10d804: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10d80b: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10d80e: 56 push %esi <== NOT EXECUTED 10d80f: 9d popf <== NOT EXECUTED 10d810: eb 23 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED * in the specified heap. * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. 10d812: 8b 59 5c mov 0x5c(%ecx),%ebx <== NOT EXECUTED 10d815: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d817: 75 20 jne 10d839 <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED */ 10d819: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10d81c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d81e: 74 05 je 10d825 <_CORE_mutex_Seize_interrupt_trylock+0xb9> <== NOT EXECUTED 10d820: 48 dec %eax <== NOT EXECUTED 10d821: 75 16 jne 10d839 <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED 10d823: eb 07 jmp 10d82c <_CORE_mutex_Seize_interrupt_trylock+0xc0> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10d825: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10d828: 56 push %esi <== NOT EXECUTED 10d829: 9d popf <== NOT EXECUTED 10d82a: eb 09 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED ); #ifdef __cplusplus 10d82c: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx) <== NOT EXECUTED } 10d833: 56 push %esi <== NOT EXECUTED 10d834: 9d popf <== NOT EXECUTED 10d835: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d837: eb 05 jmp 10d83e <_CORE_mutex_Seize_interrupt_trylock+0xd2> <== NOT EXECUTED 10d839: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10d83e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d841: 5b pop %ebx <== NOT EXECUTED 10d842: 5e pop %esi <== NOT EXECUTED 10d843: c9 leave <== NOT EXECUTED 10d844: c3 ret <== NOT EXECUTED 00109cf8 <_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 ) { 109cf8: 55 push %ebp <== NOT EXECUTED 109cf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cfb: 53 push %ebx <== NOT EXECUTED 109cfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109cff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 109d02: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 109d05: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 109d09: 74 11 je 109d1c <_CORE_mutex_Surrender+0x24> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 109d0b: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109d10: 3b 0d c0 ca 11 00 cmp 0x11cac0,%ecx <== NOT EXECUTED 109d16: 0f 85 cb 00 00 00 jne 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 109d1c: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 109d1f: 85 c0 test %eax,%eax <== NOT EXECUTED 109d21: 0f 84 be 00 00 00 je 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 109d27: 48 dec %eax <== NOT EXECUTED 109d28: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 109d2b: 85 c0 test %eax,%eax <== NOT EXECUTED 109d2d: 74 17 je 109d46 <_CORE_mutex_Surrender+0x4e> <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 109d2f: 8b 53 40 mov 0x40(%ebx),%edx <== NOT EXECUTED 109d32: 85 d2 test %edx,%edx <== NOT EXECUTED 109d34: 0f 84 ab 00 00 00 je 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109d3a: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109d3f: 4a dec %edx <== NOT EXECUTED 109d40: 0f 84 a1 00 00 00 je 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109d46: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109d49: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109d4c: 74 05 je 109d53 <_CORE_mutex_Surrender+0x5b> <== NOT EXECUTED 109d4e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109d51: 75 03 jne 109d56 <_CORE_mutex_Surrender+0x5e> <== NOT EXECUTED the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 109d53: ff 49 1c decl 0x1c(%ecx) <== NOT EXECUTED } the_mutex->holder = NULL; 109d56: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109d5d: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 109d64: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109d67: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109d6a: 74 05 je 109d71 <_CORE_mutex_Surrender+0x79> <== NOT EXECUTED 109d6c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109d6f: 75 1b jne 109d8c <_CORE_mutex_Surrender+0x94> <== 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 && 109d71: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 109d75: 75 15 jne 109d8c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED 109d77: 8b 41 18 mov 0x18(%ecx),%eax <== NOT EXECUTED 109d7a: 3b 41 14 cmp 0x14(%ecx),%eax <== NOT EXECUTED 109d7d: 74 0d je 109d8c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 109d7f: 52 push %edx <== NOT EXECUTED 109d80: 6a 01 push $0x1 <== NOT EXECUTED 109d82: 50 push %eax <== NOT EXECUTED 109d83: 51 push %ecx <== NOT EXECUTED 109d84: e8 97 0b 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109d89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 109d8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d8f: 53 push %ebx <== NOT EXECUTED 109d90: e8 63 13 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109d95: 89 c2 mov %eax,%edx <== NOT EXECUTED 109d97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d9a: 85 c0 test %eax,%eax <== NOT EXECUTED 109d9c: 74 40 je 109dde <_CORE_mutex_Surrender+0xe6> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 109d9e: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 109da1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109da4: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 109da7: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 109dae: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109db1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109db4: 74 07 je 109dbd <_CORE_mutex_Surrender+0xc5> <== NOT EXECUTED 109db6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109db9: 75 2a jne 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109dbb: eb 05 jmp 109dc2 <_CORE_mutex_Surrender+0xca> <== 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++; 109dbd: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109dc0: eb 23 jmp 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 109dc2: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 109dc5: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 109dc8: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 109dcb: 73 18 jae 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 109dcd: 51 push %ecx <== NOT EXECUTED 109dce: 6a 00 push $0x0 <== NOT EXECUTED 109dd0: 50 push %eax <== NOT EXECUTED 109dd1: 52 push %edx <== NOT EXECUTED 109dd2: e8 49 0b 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109dd7: 31 c0 xor %eax,%eax <== NOT EXECUTED 109dd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ddc: eb 09 jmp 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 109dde: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 109de5: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 109de7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109dea: c9 leave <== NOT EXECUTED 109deb: c3 ret <== NOT EXECUTED 00109dec <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109dec: 55 push %ebp <== NOT EXECUTED 109ded: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 109def: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109df0: e9 27 16 00 00 jmp 10b41c <_Thread_queue_Flush> <== NOT EXECUTED 00109df8 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 109df8: 55 push %ebp <== NOT EXECUTED 109df9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109dfb: 53 push %ebx <== NOT EXECUTED 109dfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109dff: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109e02: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 109e05: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 109e07: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 109e0a: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 109e0d: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 109e10: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 109e13: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 109e16: 6a 03 push $0x3 <== NOT EXECUTED 109e18: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 109e1d: 31 c0 xor %eax,%eax <== NOT EXECUTED 109e1f: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 109e23: 0f 94 c0 sete %al <== NOT EXECUTED 109e26: 50 push %eax <== NOT EXECUTED 109e27: 51 push %ecx <== NOT EXECUTED 109e28: e8 17 16 00 00 call 10b444 <_Thread_queue_Initialize> <== NOT EXECUTED 109e2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_semaphore_Is_priority( the_semaphore_attributes ) ? THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_SEMAPHORE, CORE_SEMAPHORE_TIMEOUT ); } 109e30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e33: c9 leave <== NOT EXECUTED 109e34: c3 ret <== NOT EXECUTED 00109e38 <_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 ) { 109e38: 55 push %ebp <== NOT EXECUTED 109e39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e3b: 53 push %ebx <== NOT EXECUTED 109e3c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109e3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 109e42: 53 push %ebx <== NOT EXECUTED 109e43: e8 b0 12 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109e48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e4b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109e4d: 85 c0 test %eax,%eax <== NOT EXECUTED 109e4f: 75 18 jne 109e69 <_CORE_semaphore_Surrender+0x31> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 109e51: 9c pushf <== NOT EXECUTED 109e52: fa cli <== NOT EXECUTED 109e53: 59 pop %ecx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 109e54: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109e57: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 109e5c: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 109e5f: 73 06 jae 109e67 <_CORE_semaphore_Surrender+0x2f> <== NOT EXECUTED the_semaphore->count += 1; 109e61: 40 inc %eax <== NOT EXECUTED 109e62: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 109e65: 31 d2 xor %edx,%edx <== NOT EXECUTED else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 109e67: 51 push %ecx <== NOT EXECUTED 109e68: 9d popf <== NOT EXECUTED } return status; } 109e69: 89 d0 mov %edx,%eax <== NOT EXECUTED 109e6b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e6e: c9 leave <== NOT EXECUTED 109e6f: c3 ret <== NOT EXECUTED 00109a20 <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 109a20: 55 push %ebp <== NOT EXECUTED 109a21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a23: 53 push %ebx <== NOT EXECUTED 109a24: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109a27: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 109a2a: 9c pushf <== NOT EXECUTED 109a2b: fa cli <== NOT EXECUTED 109a2c: 5b pop %ebx <== NOT EXECUTED 109a2d: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109a30: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109a32: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 109a35: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 109a38: 89 10 mov %edx,(%eax) <== NOT EXECUTED 109a3a: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 109a3d: 53 push %ebx <== NOT EXECUTED 109a3e: 9d popf <== NOT EXECUTED } 109a3f: 5b pop %ebx <== NOT EXECUTED 109a40: c9 leave <== NOT EXECUTED 109a41: c3 ret <== NOT EXECUTED 0010d650 <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10d650: 55 push %ebp <== NOT EXECUTED 10d651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d653: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10d656: 9c pushf <== NOT EXECUTED 10d657: fa cli <== NOT EXECUTED 10d658: 59 pop %ecx <== NOT EXECUTED 10d659: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d65b: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10d65e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d661: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10d663: 51 push %ecx <== NOT EXECUTED 10d664: 9d popf <== NOT EXECUTED } 10d665: c9 leave <== NOT EXECUTED 10d666: c3 ret <== NOT EXECUTED 00109a44 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 109a44: 55 push %ebp <== NOT EXECUTED 109a45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a47: 53 push %ebx <== NOT EXECUTED 109a48: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 109a4b: 9c pushf <== NOT EXECUTED 109a4c: fa cli <== NOT EXECUTED 109a4d: 5b pop %ebx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 109a4e: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 109a50: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109a53: 39 c2 cmp %eax,%edx <== NOT EXECUTED 109a55: 75 04 jne 109a5b <_Chain_Get+0x17> <== NOT EXECUTED 109a57: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a59: eb 07 jmp 109a62 <_Chain_Get+0x1e> <== NOT EXECUTED 109a5b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 109a5d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 109a5f: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 109a62: 53 push %ebx <== NOT EXECUTED 109a63: 9d popf <== NOT EXECUTED return return_node; } 109a64: 89 d0 mov %edx,%eax <== NOT EXECUTED 109a66: 5b pop %ebx <== NOT EXECUTED 109a67: c9 leave <== NOT EXECUTED 109a68: c3 ret <== NOT EXECUTED 0010d668 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10d668: 55 push %ebp <== NOT EXECUTED 10d669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d66b: 56 push %esi <== NOT EXECUTED 10d66c: 53 push %ebx <== NOT EXECUTED 10d66d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d670: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10d673: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10d676: 89 da mov %ebx,%edx <== NOT EXECUTED Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 10d678: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED next = starting_address; 10d67f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d682: eb 0a jmp 10d68e <_Chain_Initialize+0x26> <== NOT EXECUTED while ( count-- ) { current->next = next; 10d684: 89 02 mov %eax,(%edx) <== NOT EXECUTED next->previous = current; 10d686: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10d689: 49 dec %ecx <== NOT EXECUTED 10d68a: 89 c2 mov %eax,%edx <== NOT EXECUTED 10d68c: 01 f0 add %esi,%eax <== NOT EXECUTED count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 10d68e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d690: 75 f2 jne 10d684 <_Chain_Initialize+0x1c> <== NOT EXECUTED next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 10d692: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10d695: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_chain->last = current; 10d697: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED } 10d69a: 5b pop %ebx <== NOT EXECUTED 10d69b: 5e pop %esi <== NOT EXECUTED 10d69c: c9 leave <== NOT EXECUTED 10d69d: c3 ret <== NOT EXECUTED 001216e0 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 1216e0: 55 push %ebp <== NOT EXECUTED 1216e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1216e3: 53 push %ebx <== NOT EXECUTED 1216e4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1216e7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1216ea: 9c pushf <== NOT EXECUTED 1216eb: fa cli <== NOT EXECUTED 1216ec: 5b pop %ebx <== NOT EXECUTED 1216ed: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 1216f0: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 1216f2: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1216f4: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1216f6: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 1216f9: 53 push %ebx <== NOT EXECUTED 1216fa: 9d popf <== NOT EXECUTED } 1216fb: 5b pop %ebx <== NOT EXECUTED 1216fc: c9 leave <== NOT EXECUTED 1216fd: c3 ret <== NOT EXECUTED 0010d5fd <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10d5fd: 55 push %ebp <== NOT EXECUTED 10d5fe: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d600: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d603: 85 05 c4 ca 11 00 test %eax,0x11cac4 <== NOT EXECUTED 10d609: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10d60c: c9 leave <== NOT EXECUTED 10d60d: c3 ret <== NOT EXECUTED 0010d5d0 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10d5d0: 55 push %ebp <== NOT EXECUTED 10d5d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10d5d3: c7 05 c4 ca 11 00 00 movl $0x0,0x11cac4 <== NOT EXECUTED 10d5da: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10d5dd: c9 leave <== NOT EXECUTED 10d5de: c3 ret <== NOT EXECUTED 0010d26c <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10d26c: 55 push %ebp <== NOT EXECUTED 10d26d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d26f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d272: 6a 04 push $0x4 <== NOT EXECUTED 10d274: 6a 00 push $0x0 <== NOT EXECUTED 10d276: 6a 1c push $0x1c <== NOT EXECUTED 10d278: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d27b: 6a 07 push $0x7 <== NOT EXECUTED 10d27d: 6a 02 push $0x2 <== NOT EXECUTED 10d27f: 68 74 cd 11 00 push $0x11cd74 <== NOT EXECUTED 10d284: e8 cf d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d289: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d28c: c9 leave <== NOT EXECUTED 10d28d: c3 ret <== NOT EXECUTED 0010d290 <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10d290: 55 push %ebp <== NOT EXECUTED 10d291: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10d293: c7 05 a8 cc 11 00 00 movl $0x0,0x11cca8 <== NOT EXECUTED 10d29a: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10d29d: c9 leave <== NOT EXECUTED 10d29e: c3 ret <== NOT EXECUTED 00108ba0 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108ba0: 55 push %ebp <== NOT EXECUTED 108ba1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ba3: 57 push %edi <== NOT EXECUTED 108ba4: 56 push %esi <== NOT EXECUTED 108ba5: 53 push %ebx <== NOT EXECUTED 108ba6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ba9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108bac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 108baf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 108bb2: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 108bb5: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 108bb8: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 108bbb: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED executing->Wait.return_code = RTEMS_SUCCESSFUL; 108bc1: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 108bc8: 8b 93 f4 00 00 00 mov 0xf4(%ebx),%edx <== NOT EXECUTED 108bce: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 108bd1: 9c pushf <== NOT EXECUTED 108bd2: fa cli <== NOT EXECUTED 108bd3: 5f pop %edi <== NOT EXECUTED pending_events = api->pending_events; 108bd4: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 108bd7: 8b 11 mov (%ecx),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 108bd9: 89 c1 mov %eax,%ecx <== NOT EXECUTED 108bdb: 21 d1 and %edx,%ecx <== NOT EXECUTED 108bdd: 74 23 je 108c02 <_Event_Seize+0x62> <== NOT EXECUTED 108bdf: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 108be1: 74 08 je 108beb <_Event_Seize+0x4b> <== NOT EXECUTED 108be3: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 108be9: 74 17 je 108c02 <_Event_Seize+0x62> <== NOT EXECUTED (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 108beb: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108bed: f7 d0 not %eax <== NOT EXECUTED 108bef: 21 d0 and %edx,%eax <== NOT EXECUTED 108bf1: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108bf4: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 108bf6: 57 push %edi <== NOT EXECUTED 108bf7: 9d popf <== NOT EXECUTED *event_out = seized_events; 108bf8: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108bfb: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 108bfd: e9 ad 00 00 00 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED return; } if ( _Options_Is_no_wait( option_set ) ) { 108c02: f7 c6 01 00 00 00 test $0x1,%esi <== NOT EXECUTED 108c08: 74 13 je 108c1d <_Event_Seize+0x7d> <== NOT EXECUTED _ISR_Enable( level ); 108c0a: 57 push %edi <== NOT EXECUTED 108c0b: 9d popf <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; 108c0c: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) <== NOT EXECUTED *event_out = seized_events; 108c13: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 108c16: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 108c18: e9 92 00 00 00 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 108c1d: c7 05 a8 cc 11 00 01 movl $0x1,0x11cca8 <== NOT EXECUTED 108c24: 00 00 00 <== NOT EXECUTED executing->Wait.option = (uint32_t) option_set; 108c27: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED executing->Wait.count = (uint32_t) event_in; 108c2a: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED executing->Wait.return_argument = event_out; 108c2d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108c30: 89 4b 28 mov %ecx,0x28(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 108c33: 57 push %edi <== NOT EXECUTED 108c34: 9d popf <== NOT EXECUTED if ( ticks ) { 108c35: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 108c39: 74 34 je 108c6f <_Event_Seize+0xcf> <== NOT EXECUTED _Watchdog_Initialize( 108c3b: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 108c3e: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 108c45: c7 43 64 f0 8d 10 00 movl $0x108df0,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 108c4c: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 108c4f: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 108c56: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 108c59: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 108c5c: 52 push %edx <== NOT EXECUTED 108c5d: 52 push %edx <== NOT EXECUTED 108c5e: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 108c61: 50 push %eax <== NOT EXECUTED 108c62: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 108c67: e8 f0 2e 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 108c6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 108c6f: 50 push %eax <== NOT EXECUTED 108c70: 50 push %eax <== NOT EXECUTED 108c71: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 108c76: 53 push %ebx <== NOT EXECUTED 108c77: e8 34 29 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED _ISR_Disable( level ); 108c7c: 9c pushf <== NOT EXECUTED 108c7d: fa cli <== NOT EXECUTED 108c7e: 5a pop %edx <== NOT EXECUTED sync_state = _Event_Sync_state; 108c7f: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 108c84: c7 05 a8 cc 11 00 00 movl $0x0,0x11cca8 <== NOT EXECUTED 108c8b: 00 00 00 <== NOT EXECUTED if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 108c8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c91: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108c94: 75 04 jne 108c9a <_Event_Seize+0xfa> <== NOT EXECUTED _ISR_Enable( level ); 108c96: 52 push %edx <== NOT EXECUTED 108c97: 9d popf <== NOT EXECUTED 108c98: eb 15 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108c9a: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 108c9d: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 108ca0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 108ca3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108ca6: 5b pop %ebx <== NOT EXECUTED 108ca7: 5e pop %esi <== NOT EXECUTED 108ca8: 5f pop %edi <== NOT EXECUTED 108ca9: c9 leave <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108caa: e9 25 1c 00 00 jmp 10a8d4 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED } 108caf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108cb2: 5b pop %ebx <== NOT EXECUTED 108cb3: 5e pop %esi <== NOT EXECUTED 108cb4: 5f pop %edi <== NOT EXECUTED 108cb5: c9 leave <== NOT EXECUTED 108cb6: c3 ret <== NOT EXECUTED 00108d04 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 108d04: 55 push %ebp <== NOT EXECUTED 108d05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108d07: 57 push %edi <== NOT EXECUTED 108d08: 56 push %esi <== NOT EXECUTED 108d09: 53 push %ebx <== NOT EXECUTED 108d0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d0d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 108d10: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax <== NOT EXECUTED 108d16: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED option_set = (rtems_option) the_thread->Wait.option; 108d19: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 108d1c: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 108d1f: 9c pushf <== NOT EXECUTED 108d20: fa cli <== NOT EXECUTED 108d21: 5f pop %edi <== NOT EXECUTED pending_events = api->pending_events; 108d22: 8b 30 mov (%eax),%esi <== NOT EXECUTED event_condition = (rtems_event_set) the_thread->Wait.count; 108d24: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 108d27: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108d29: 21 f1 and %esi,%ecx <== NOT EXECUTED 108d2b: 75 07 jne 108d34 <_Event_Surrender+0x30> <== NOT EXECUTED _ISR_Enable( level ); 108d2d: 57 push %edi <== NOT EXECUTED 108d2e: 9d popf <== NOT EXECUTED 108d2f: e9 b1 00 00 00 jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 108d34: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 108d39: 85 c0 test %eax,%eax <== NOT EXECUTED 108d3b: 74 49 je 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d3d: 3b 1d c0 ca 11 00 cmp 0x11cac0,%ebx <== NOT EXECUTED 108d43: 75 41 jne 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d45: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED 108d4a: 48 dec %eax <== NOT EXECUTED 108d4b: 74 0a je 108d57 <_Event_Surrender+0x53> <== NOT EXECUTED 108d4d: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED 108d52: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 108d55: 75 2f jne 108d86 <_Event_Surrender+0x82> <== 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) ) { 108d57: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 108d59: 74 06 je 108d61 <_Event_Surrender+0x5d> <== NOT EXECUTED 108d5b: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED 108d5f: 74 21 je 108d82 <_Event_Surrender+0x7e> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 108d61: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108d63: f7 d0 not %eax <== NOT EXECUTED 108d65: 21 f0 and %esi,%eax <== NOT EXECUTED 108d67: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108d6a: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->Wait.count = 0; 108d6c: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108d73: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108d76: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 108d78: c7 05 a8 cc 11 00 03 movl $0x3,0x11cca8 <== NOT EXECUTED 108d7f: 00 00 00 <== NOT EXECUTED } _ISR_Enable( level ); 108d82: 57 push %edi <== NOT EXECUTED 108d83: 9d popf <== NOT EXECUTED 108d84: eb 5f jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 108d86: f6 43 11 01 testb $0x1,0x11(%ebx) <== NOT EXECUTED 108d8a: 74 57 je 108de3 <_Event_Surrender+0xdf> <== NOT EXECUTED if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 108d8c: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 108d8e: 74 06 je 108d96 <_Event_Surrender+0x92> <== NOT EXECUTED 108d90: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED 108d94: 74 4d je 108de3 <_Event_Surrender+0xdf> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 108d96: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108d98: f7 d0 not %eax <== NOT EXECUTED 108d9a: 21 f0 and %esi,%eax <== NOT EXECUTED 108d9c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108d9f: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->Wait.count = 0; 108da1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108da8: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108dab: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _ISR_Flash( level ); 108dad: 57 push %edi <== NOT EXECUTED 108dae: 9d popf <== NOT EXECUTED 108daf: fa cli <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 108db0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 108db4: 74 06 je 108dbc <_Event_Surrender+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 108db6: 57 push %edi <== NOT EXECUTED 108db7: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108db8: 51 push %ecx <== NOT EXECUTED 108db9: 51 push %ecx <== NOT EXECUTED 108dba: eb 17 jmp 108dd3 <_Event_Surrender+0xcf> <== 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 */ 108dbc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 108dc3: 57 push %edi <== NOT EXECUTED 108dc4: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 108dc5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108dc8: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 108dcb: 50 push %eax <== NOT EXECUTED 108dcc: e8 a3 2e 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108dd1: 58 pop %eax <== NOT EXECUTED 108dd2: 5a pop %edx <== NOT EXECUTED 108dd3: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 108dd8: 53 push %ebx <== NOT EXECUTED 108dd9: e8 62 1c 00 00 call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 108dde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108de1: eb 02 jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 108de3: 57 push %edi <== NOT EXECUTED 108de4: 9d popf <== NOT EXECUTED } 108de5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108de8: 5b pop %ebx <== NOT EXECUTED 108de9: 5e pop %esi <== NOT EXECUTED 108dea: 5f pop %edi <== NOT EXECUTED 108deb: c9 leave <== NOT EXECUTED 108dec: c3 ret <== NOT EXECUTED 00108df0 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 108df0: 55 push %ebp <== NOT EXECUTED 108df1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108df3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 108df6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 108df9: 50 push %eax <== NOT EXECUTED 108dfa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108dfd: e8 de 1f 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 108e02: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 108e04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e07: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 108e0b: 75 5f jne 108e6c <_Event_Timeout+0x7c> <== NOT EXECUTED * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 108e0d: 9c pushf <== NOT EXECUTED 108e0e: fa cli <== NOT EXECUTED 108e0f: 59 pop %ecx <== NOT EXECUTED if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 108e10: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 108e14: 75 0f jne 108e25 <_Event_Timeout+0x35> <== NOT EXECUTED 108e16: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108e1b: 48 dec %eax <== NOT EXECUTED 108e1c: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Unnest_dispatch(); _ISR_Enable( level ); 108e21: 51 push %ecx <== NOT EXECUTED 108e22: 9d popf <== NOT EXECUTED 108e23: eb 47 jmp 108e6c <_Event_Timeout+0x7c> <== NOT EXECUTED return; } the_thread->Wait.count = 0; 108e25: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 108e2c: 3b 05 c0 ca 11 00 cmp 0x11cac0,%eax <== NOT EXECUTED 108e32: 75 14 jne 108e48 <_Event_Timeout+0x58> <== NOT EXECUTED Thread_blocking_operation_States sync = _Event_Sync_state; 108e34: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 108e39: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108e3c: 77 0a ja 108e48 <_Event_Timeout+0x58> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 108e3e: c7 05 a8 cc 11 00 02 movl $0x2,0x11cca8 <== NOT EXECUTED 108e45: 00 00 00 <== NOT EXECUTED } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 108e48: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 108e4f: 51 push %ecx <== NOT EXECUTED 108e50: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108e51: 50 push %eax <== NOT EXECUTED 108e52: 50 push %eax <== NOT EXECUTED 108e53: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 108e58: 52 push %edx <== NOT EXECUTED 108e59: e8 e2 1b 00 00 call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 108e5e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108e63: 48 dec %eax <== NOT EXECUTED 108e64: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 108e69: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 108e6c: c9 leave <== NOT EXECUTED 108e6d: c3 ret <== NOT EXECUTED 0010973c <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10973c: 55 push %ebp <== NOT EXECUTED 10973d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10973f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 109742: 6a 04 push $0x4 <== NOT EXECUTED 109744: 6a 00 push $0x0 <== NOT EXECUTED 109746: 6a 44 push $0x44 <== NOT EXECUTED 109748: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10974b: 6a 09 push $0x9 <== NOT EXECUTED 10974d: 6a 02 push $0x2 <== NOT EXECUTED 10974f: 68 ec cc 11 00 push $0x11ccec <== NOT EXECUTED 109754: e8 ff 0e 00 00 call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 109759: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10975c: c9 leave <== NOT EXECUTED 10975d: c3 ret <== NOT EXECUTED 0010d89c <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10d89c: 55 push %ebp <== NOT EXECUTED 10d89d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d89f: 57 push %edi <== NOT EXECUTED 10d8a0: 56 push %esi <== NOT EXECUTED 10d8a1: 53 push %ebx <== NOT EXECUTED 10d8a2: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d8a5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 10d8a8: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10d8ab: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10d8ae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d8b1: e8 b9 c7 ff ff call 10a06f <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10d8b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8b9: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d8bb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8bd: 74 3c je 10d8fb <_Heap_Allocate+0x5f> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10d8bf: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED 10d8c2: 31 ff xor %edi,%edi <== NOT EXECUTED 10d8c4: eb 27 jmp 10d8ed <_Heap_Allocate+0x51> <== NOT EXECUTED /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 10d8c6: 39 43 04 cmp %eax,0x4(%ebx) <== NOT EXECUTED 10d8c9: 72 1e jb 10d8e9 <_Heap_Allocate+0x4d> <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10d8cb: 52 push %edx <== NOT EXECUTED 10d8cc: 50 push %eax <== NOT EXECUTED 10d8cd: 53 push %ebx <== NOT EXECUTED 10d8ce: 56 push %esi <== NOT EXECUTED 10d8cf: e8 d8 c7 ff ff call 10a0ac <_Heap_Block_allocate> <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10d8d4: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10d8d7: ff 46 48 incl 0x48(%esi) <== NOT EXECUTED stats->searches += search_count + 1; 10d8da: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10d8dd: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax <== NOT EXECUTED 10d8e1: 89 46 4c mov %eax,0x4c(%esi) <== NOT EXECUTED 10d8e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8e7: eb 0a jmp 10d8f3 <_Heap_Allocate+0x57> <== NOT EXECUTED return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10d8e9: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10d8ec: 47 inc %edi <== NOT EXECUTED if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10d8ed: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10d8ef: 75 d5 jne 10d8c6 <_Heap_Allocate+0x2a> <== NOT EXECUTED 10d8f1: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10d8f3: 39 7e 44 cmp %edi,0x44(%esi) <== NOT EXECUTED 10d8f6: 73 03 jae 10d8fb <_Heap_Allocate+0x5f> <== NOT EXECUTED stats->max_search = search_count; 10d8f8: 89 7e 44 mov %edi,0x44(%esi) <== NOT EXECUTED return ptr; } 10d8fb: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d8fd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d900: 5b pop %ebx <== NOT EXECUTED 10d901: 5e pop %esi <== NOT EXECUTED 10d902: 5f pop %edi <== NOT EXECUTED 10d903: c9 leave <== NOT EXECUTED 10d904: c3 ret <== NOT EXECUTED 0010b72c <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10b72c: 55 push %ebp <== NOT EXECUTED 10b72d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b72f: 57 push %edi <== NOT EXECUTED 10b730: 56 push %esi <== NOT EXECUTED 10b731: 53 push %ebx <== NOT EXECUTED 10b732: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED 10b735: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 10b738: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b73b: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10b73e: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET; 10b741: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10b744: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 10b747: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b74a: ff 72 14 pushl 0x14(%edx) <== NOT EXECUTED 10b74d: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10b750: 50 push %eax <== NOT EXECUTED 10b751: e8 2d 04 00 00 call 10bb83 <_Heap_Calc_block_size> <== NOT EXECUTED 10b756: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10b759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b75c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b75e: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10b762: 0f 84 30 01 00 00 je 10b898 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED return NULL; if(alignment == 0) 10b768: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10b76c: 75 07 jne 10b775 <_Heap_Allocate_aligned+0x49> <== NOT EXECUTED 10b76e: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10b775: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b778: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED 10b77b: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED 10b782: e9 f8 00 00 00 jmp 10b87f <_Heap_Allocate_aligned+0x153> <== NOT EXECUTED 10b787: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b78a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10b78d: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 10b790: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10b793: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b795: 0f 82 de 00 00 00 jb 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 10b79b: 8d 4b 08 lea 0x8(%ebx),%ecx <== NOT EXECUTED /* Calculate 'aligned_user_addr' that will become the user pointer we return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; 10b79e: 01 d8 add %ebx,%eax <== NOT EXECUTED 10b7a0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10b7a3: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b7a5: 2b 75 e0 sub -0x20(%ebp),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10b7a8: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b7aa: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7ac: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b7af: 89 f7 mov %esi,%edi <== NOT EXECUTED 10b7b1: 29 d7 sub %edx,%edi <== NOT EXECUTED 10b7b3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b7b5: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7b7: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10b7ba: 89 fe mov %edi,%esi <== NOT EXECUTED 10b7bc: 29 d6 sub %edx,%esi <== NOT EXECUTED only at 'page_size' aligned addresses */ user_addr = aligned_user_addr; _Heap_Align_down_uptr(&user_addr, page_size); /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */ if(user_addr >= user_area) { 10b7be: 39 ce cmp %ecx,%esi <== NOT EXECUTED 10b7c0: 0f 82 b3 00 00 00 jb 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED /* The block seems to be acceptable. Check if the remainder of 'the_block' is less than 'min_block_size' so that 'the_block' won't actually be split at the address we assume. */ if(user_addr - user_area < the_heap->min_block_size) { 10b7c6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7c9: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b7cc: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b7cf: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b7d1: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7d3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7d5: 73 2f jae 10b806 <_Heap_Allocate_aligned+0xda> <== NOT EXECUTED 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 10b7d7: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b7d9: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7db: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b7dd: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b7e0: 72 24 jb 10b806 <_Heap_Allocate_aligned+0xda> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10b7e2: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b7e4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7e6: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b7e9: 89 d6 mov %edx,%esi <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10b7eb: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b7ed: 85 f6 test %esi,%esi <== NOT EXECUTED 10b7ef: 74 08 je 10b7f9 <_Heap_Allocate_aligned+0xcd> <== NOT EXECUTED 10b7f1: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b7f4: 8d 14 01 lea (%ecx,%eax,1),%edx <== NOT EXECUTED 10b7f7: 29 f2 sub %esi,%edx <== NOT EXECUTED /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 10b7f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b7fb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7fd: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b800: 73 77 jae 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED 10b802: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b804: 89 d7 mov %edx,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10b806: 85 ff test %edi,%edi <== NOT EXECUTED 10b808: 74 6f je 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED /* The block is indeed acceptable: calculate the size of the block to be allocated and perform allocation. */ uint32_t const alloc_size = block_end - user_addr + HEAP_BLOCK_USER_OFFSET; 10b80a: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10b80d: 83 c2 08 add $0x8,%edx <== NOT EXECUTED 10b810: 29 f2 sub %esi,%edx <== NOT EXECUTED Heap_Block *the_block, uint32_t alloc_size) { Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10b812: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 10b815: 29 d1 sub %edx,%ecx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10b817: 3b 4d f0 cmp -0x10(%ebp),%ecx <== NOT EXECUTED 10b81a: 72 14 jb 10b830 <_Heap_Allocate_aligned+0x104> <== NOT EXECUTED /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 10b81c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b81e: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b821: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10b824: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10b827: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10b829: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10b82b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10b82e: eb 15 jmp 10b845 <_Heap_Allocate_aligned+0x119> <== NOT EXECUTED * This routine resets the current context of the calling thread * to that of its initial state. */ RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void ) { 10b830: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10b833: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10b836: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10b839: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; 10b83c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b83f: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b842: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10b845: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10b84a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b84d: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10b850: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b852: 89 41 30 mov %eax,0x30(%ecx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b855: 39 41 34 cmp %eax,0x34(%ecx) <== NOT EXECUTED 10b858: 76 03 jbe 10b85d <_Heap_Allocate_aligned+0x131> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b85a: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10b85d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b860: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 10b863: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b865: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10b868: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 10b86b: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax <== NOT EXECUTED 10b86f: 89 42 4c mov %eax,0x4c(%edx) <== NOT EXECUTED stats->allocs += 1; 10b872: ff 42 48 incl 0x48(%edx) <== NOT EXECUTED check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10b875: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b877: eb 11 jmp 10b88a <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10b879: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10b87c: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10b87f: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10b882: 0f 85 ff fe ff ff jne 10b787 <_Heap_Allocate_aligned+0x5b> <== NOT EXECUTED 10b888: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10b88a: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b88d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b890: 39 51 44 cmp %edx,0x44(%ecx) <== NOT EXECUTED 10b893: 73 03 jae 10b898 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED stats->max_search = search_count; 10b895: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED return user_ptr; } 10b898: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b89b: 5b pop %ebx <== NOT EXECUTED 10b89c: 5e pop %esi <== NOT EXECUTED 10b89d: 5f pop %edi <== NOT EXECUTED 10b89e: c9 leave <== NOT EXECUTED 10b89f: c3 ret <== NOT EXECUTED 0010a0ac <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10a0ac: 55 push %ebp <== NOT EXECUTED 10a0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0af: 57 push %edi <== NOT EXECUTED 10a0b0: 56 push %esi <== NOT EXECUTED 10a0b1: 53 push %ebx <== NOT EXECUTED 10a0b2: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a0b5: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10a0b8: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a0bb: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10a0be: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a0c0: 29 fb sub %edi,%ebx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10a0c2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a0c5: 3b 5a 14 cmp 0x14(%edx),%ebx <== NOT EXECUTED 10a0c8: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10a0cb: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 10a0ce: 72 24 jb 10a0f4 <_Heap_Block_allocate+0x48> <== NOT EXECUTED 10a0d0: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 10a0d3: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED ); 10a0d6: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10a0d9: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10a0dc: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED becomes used. This is slightly less optimal than leaving lower part free as it requires replacing block in the free blocks list, but it makes it possible to reuse this code in the _Heap_Resize_block(). */ Heap_Block *next_block = _Heap_Block_at(the_block, alloc_size); _Heap_Block_replace(the_block, next_block); the_block->size = alloc_size | HEAP_PREV_USED; 10a0df: 89 fa mov %edi,%edx <== NOT EXECUTED 10a0e1: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a0e4: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10a0e7: 89 da mov %ebx,%edx <== NOT EXECUTED 10a0e9: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a0ec: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10a0ef: 89 1c 18 mov %ebx,(%eax,%ebx,1) <== NOT EXECUTED 10a0f2: eb 13 jmp 10a107 <_Heap_Block_allocate+0x5b> <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10a0f4: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10a0f7: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10a0fa: 83 4c 06 04 01 orl $0x1,0x4(%esi,%eax,1) <== NOT EXECUTED stats->free_blocks -= 1; 10a0ff: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a102: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10a105: 89 c7 mov %eax,%edi <== NOT EXECUTED } /* Update statistics */ stats->free_size -= alloc_size; 10a107: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a10a: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10a10d: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a10f: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10a112: 39 42 34 cmp %eax,0x34(%edx) <== NOT EXECUTED 10a115: 76 03 jbe 10a11a <_Heap_Block_allocate+0x6e> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10a117: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10a11a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a11d: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10a120: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a122: 5b pop %ebx <== NOT EXECUTED 10a123: 5e pop %esi <== NOT EXECUTED 10a124: 5f pop %edi <== NOT EXECUTED 10a125: c9 leave <== NOT EXECUTED 10a126: c3 ret <== NOT EXECUTED 0010a06f <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10a06f: 55 push %ebp <== NOT EXECUTED 10a070: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a072: 57 push %edi <== NOT EXECUTED 10a073: 56 push %esi <== NOT EXECUTED 10a074: 53 push %ebx <== NOT EXECUTED 10a075: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a078: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a07b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a07e: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10a081: 8d 7e 04 lea 0x4(%esi),%edi <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 10a084: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a086: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a088: f7 f1 div %ecx <== NOT EXECUTED */ 10a08a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a08c: 74 05 je 10a093 <_Heap_Calc_block_size+0x24> <== NOT EXECUTED 10a08e: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 10a091: 29 d7 sub %edx,%edi <== NOT EXECUTED 10a093: 89 fa mov %edi,%edx <== NOT EXECUTED 10a095: 39 df cmp %ebx,%edi <== NOT EXECUTED 10a097: 73 02 jae 10a09b <_Heap_Calc_block_size+0x2c> <== NOT EXECUTED 10a099: 89 da mov %ebx,%edx <== NOT EXECUTED _Heap_Align_up(&block_size, page_size); if (block_size < min_size) block_size = min_size; /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 10a09b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a09d: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a09f: 0f 97 c0 seta %al <== NOT EXECUTED 10a0a2: f7 d8 neg %eax <== NOT EXECUTED 10a0a4: 21 d0 and %edx,%eax <== NOT EXECUTED } 10a0a6: 5a pop %edx <== NOT EXECUTED 10a0a7: 5b pop %ebx <== NOT EXECUTED 10a0a8: 5e pop %esi <== NOT EXECUTED 10a0a9: 5f pop %edi <== NOT EXECUTED 10a0aa: c9 leave <== NOT EXECUTED 10a0ab: c3 ret <== NOT EXECUTED 0010f874 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 10f874: 55 push %ebp <== NOT EXECUTED 10f875: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f877: 57 push %edi <== NOT EXECUTED 10f878: 56 push %esi <== NOT EXECUTED 10f879: 53 push %ebx <== NOT EXECUTED 10f87a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f87d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10f880: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f883: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 10f886: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 10f889: 72 0a jb 10f895 <_Heap_Extend+0x21> <== NOT EXECUTED 10f88b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f890: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10f893: 72 5f jb 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 10f895: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10f89a: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10f89d: 75 55 jne 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED * Currently only case 4 should make it to this point. * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; 10f89f: 8b 59 24 mov 0x24(%ecx),%ebx <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10f8a2: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 10f8a5: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 10f8a8: 29 d8 sub %ebx,%eax <== NOT EXECUTED 10f8aa: 8d 78 f8 lea -0x8(%eax),%edi <== NOT EXECUTED * the outer most dispatching critical section, then a dispatching * operation will be performed and, if necessary, control of the * processor will be transferred to the heir thread. */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ 10f8ad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10f8af: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f8b1: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 10f8b4: 29 d7 sub %edx,%edi <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 10f8b6: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10f8b9: 89 30 mov %esi,(%eax) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 10f8bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8bd: 3b 79 14 cmp 0x14(%ecx),%edi <== NOT EXECUTED 10f8c0: 72 32 jb 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 10f8c2: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f8c5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10f8c8: 09 f8 or %edi,%eax <== NOT EXECUTED 10f8ca: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10f8cd: 8d 04 3b lea (%ebx,%edi,1),%eax <== NOT EXECUTED new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 10f8d0: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 10f8d7: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 10f8da: 01 71 2c add %esi,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10f8dd: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 10f8e0: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 10f8e3: 50 push %eax <== NOT EXECUTED 10f8e4: 50 push %eax <== NOT EXECUTED 10f8e5: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f8e8: 50 push %eax <== NOT EXECUTED 10f8e9: 51 push %ecx <== NOT EXECUTED 10f8ea: e8 1d c0 ff ff call 10b90c <_Heap_Free> <== NOT EXECUTED 10f8ef: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; } 10f8f4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8f7: 5b pop %ebx <== NOT EXECUTED 10f8f8: 5e pop %esi <== NOT EXECUTED 10f8f9: 5f pop %edi <== NOT EXECUTED 10f8fa: c9 leave <== NOT EXECUTED 10f8fb: c3 ret <== NOT EXECUTED 0010d908 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10d908: 55 push %ebp <== NOT EXECUTED 10d909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d90b: 57 push %edi <== NOT EXECUTED 10d90c: 56 push %esi <== NOT EXECUTED 10d90d: 53 push %ebx <== NOT EXECUTED 10d90e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d911: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d914: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 10d917: 8b 47 24 mov 0x24(%edi),%eax <== NOT EXECUTED 10d91a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10d91d: 8b 57 20 mov 0x20(%edi),%edx <== NOT EXECUTED 10d920: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 10d923: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10d925: 0f 93 c2 setae %dl <== NOT EXECUTED 10d928: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10d92a: 0f 96 c0 setbe %al <== NOT EXECUTED 10d92d: 84 d0 test %dl,%al <== NOT EXECUTED 10d92f: 0f 84 2f 01 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d935: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 10d938: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10d93a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d93c: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10d93f: 29 d3 sub %edx,%ebx <== NOT EXECUTED return( FALSE ); } _Heap_Start_of_block( the_heap, starting_address, &the_block ); if ( !_Heap_Is_block_in( the_heap, the_block ) ) { 10d941: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10d944: 0f 93 c2 setae %dl <== NOT EXECUTED 10d947: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10d94a: 0f 96 c0 setbe %al <== NOT EXECUTED 10d94d: 84 d0 test %dl,%al <== NOT EXECUTED 10d94f: 0f 84 0f 01 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d955: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 10d958: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10d95a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10d95d: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10d960: 8d 34 03 lea (%ebx,%eax,1),%esi <== NOT EXECUTED } the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); if ( !_Heap_Is_block_in( the_heap, next_block ) ) { 10d963: 3b 75 e4 cmp -0x1c(%ebp),%esi <== NOT EXECUTED 10d966: 0f 93 c2 setae %dl <== NOT EXECUTED 10d969: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10d96c: 0f 96 c0 setbe %al <== NOT EXECUTED 10d96f: 84 d0 test %dl,%al <== NOT EXECUTED 10d971: 0f 84 ed 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d977: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10d97a: a8 01 test $0x1,%al <== NOT EXECUTED 10d97c: 0f 84 e2 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d982: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10d985: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10d988: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d98a: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10d98d: 73 0c jae 10d99b <_Heap_Free+0x93> <== NOT EXECUTED 10d98f: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10d992: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax <== NOT EXECUTED 10d996: f7 d0 not %eax <== NOT EXECUTED 10d998: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10d99b: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10d99e: 80 e1 01 and $0x1,%cl <== NOT EXECUTED 10d9a1: 75 56 jne 10d9f9 <_Heap_Free+0xf1> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10d9a3: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10d9a5: 29 cb sub %ecx,%ebx <== NOT EXECUTED Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size ); if ( !_Heap_Is_block_in( the_heap, prev_block ) ) { 10d9a7: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10d9aa: 0f 93 c2 setae %dl <== NOT EXECUTED 10d9ad: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10d9b0: 0f 96 c0 setbe %al <== NOT EXECUTED 10d9b3: 84 d0 test %dl,%al <== NOT EXECUTED 10d9b5: 0f 84 a9 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED return( FALSE ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 10d9bb: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10d9bf: 0f 84 9f 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10d9c5: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d9c9: 74 19 je 10d9e4 <_Heap_Free+0xdc> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10d9cb: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10d9ce: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10d9d1: 01 ca add %ecx,%edx <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon 10d9d3: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10d9d6: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10d9d9: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d9dc: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10d9df: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED 10d9e2: eb 33 jmp 10da17 <_Heap_Free+0x10f> <== NOT EXECUTED next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; 10d9e4: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10d9e7: 01 ca add %ecx,%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10d9e9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d9eb: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10d9ee: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10d9f1: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = size; 10d9f5: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d9f7: eb 5b jmp 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED } } else if ( next_is_free ) { /* coalesce next */ 10d9f9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d9fd: 74 25 je 10da24 <_Heap_Free+0x11c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10d9ff: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10da02: 03 55 e8 add -0x18(%ebp),%edx <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 10da05: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10da08: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10da0b: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10da0e: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10da11: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10da14: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10da17: 89 d0 mov %edx,%eax <== NOT EXECUTED 10da19: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10da1c: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10da1f: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10da22: eb 30 jmp 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10da24: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10da27: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10da2a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10da2d: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10da30: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED } else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; 10da33: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10da36: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10da39: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10da3c: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = the_size; 10da40: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10da43: 89 06 mov %eax,(%esi) <== NOT EXECUTED stats->free_blocks += 1; 10da45: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10da48: 40 inc %eax <== NOT EXECUTED 10da49: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10da4c: 39 47 3c cmp %eax,0x3c(%edi) <== NOT EXECUTED 10da4f: 73 03 jae 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10da51: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED } stats->used_blocks -= 1; 10da54: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10da57: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10da5a: 01 57 30 add %edx,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10da5d: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10da60: b0 01 mov $0x1,%al <== NOT EXECUTED 10da62: eb 02 jmp 10da66 <_Heap_Free+0x15e> <== NOT EXECUTED return( TRUE ); 10da64: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10da66: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10da69: 5b pop %ebx <== NOT EXECUTED 10da6a: 5e pop %esi <== NOT EXECUTED 10da6b: 5f pop %edi <== NOT EXECUTED 10da6c: c9 leave <== NOT EXECUTED 10da6d: c3 ret <== NOT EXECUTED 00121b64 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 121b64: 55 push %ebp <== NOT EXECUTED 121b65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121b67: 53 push %ebx <== NOT EXECUTED 121b68: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 121b6b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 121b6e: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED info->largest = 0; 121b74: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED info->total = 0; 121b7b: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 121b82: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 121b85: eb 16 jmp 121b9d <_Heap_Get_free_information+0x39> <== NOT EXECUTED 121b87: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 121b8a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 121b8d: ff 02 incl (%edx) <== NOT EXECUTED info->total += the_size; 121b8f: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( info->largest < the_size ) 121b92: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 121b95: 73 03 jae 121b9a <_Heap_Get_free_information+0x36> <== NOT EXECUTED info->largest = the_size; 121b97: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 121b9a: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 121b9d: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 121b9f: 75 e6 jne 121b87 <_Heap_Get_free_information+0x23> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 121ba1: 5b pop %ebx <== NOT EXECUTED 121ba2: c9 leave <== NOT EXECUTED 121ba3: c3 ret <== NOT EXECUTED 001296e8 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 1296e8: 55 push %ebp <== NOT EXECUTED 1296e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1296eb: 53 push %ebx <== NOT EXECUTED 1296ec: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1296ef: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 1296f2: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 1296f5: 8b 58 24 mov 0x24(%eax),%ebx <== NOT EXECUTED _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 1296f8: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED the_info->Free.total = 0; 1296fe: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED the_info->Free.largest = 0; 129705: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED the_info->Used.number = 0; 12970c: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED the_info->Used.total = 0; 129713: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED the_info->Used.largest = 0; 12971a: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 129721: eb 36 jmp 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED 129723: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 129726: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 129729: 01 c1 add %eax,%ecx <== NOT EXECUTED while ( the_block != end ) { 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) ) { 12972b: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 12972f: 74 10 je 129741 <_Heap_Get_information+0x59> <== NOT EXECUTED the_info->Used.number++; 129731: ff 42 0c incl 0xc(%edx) <== NOT EXECUTED the_info->Used.total += the_size; 129734: 01 42 14 add %eax,0x14(%edx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 129737: 39 42 10 cmp %eax,0x10(%edx) <== NOT EXECUTED 12973a: 73 1d jae 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED the_info->Used.largest = the_size; 12973c: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED 12973f: eb 18 jmp 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED } else { the_info->Free.number++; 129741: ff 02 incl (%edx) <== NOT EXECUTED the_info->Free.total += the_size; 129743: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 129746: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 129749: 73 03 jae 12974e <_Heap_Get_information+0x66> <== NOT EXECUTED the_info->Free.largest = the_size; 12974b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 12974e: 3b 01 cmp (%ecx),%eax <== NOT EXECUTED 129750: 74 07 je 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED 129752: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 129757: eb 0a jmp 129763 <_Heap_Get_information+0x7b> <== NOT EXECUTED the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 129759: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12975b: 75 c6 jne 129723 <_Heap_Get_information+0x3b> <== 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; 12975d: 83 42 14 08 addl $0x8,0x14(%edx) <== NOT EXECUTED 129761: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 129763: 5b pop %ebx <== NOT EXECUTED 129764: c9 leave <== NOT EXECUTED 129765: c3 ret <== NOT EXECUTED 00109f60 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 109f60: 55 push %ebp <== NOT EXECUTED 109f61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f63: 57 push %edi <== NOT EXECUTED 109f64: 56 push %esi <== NOT EXECUTED 109f65: 53 push %ebx <== NOT EXECUTED 109f66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f69: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109f6c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 109f6f: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 109f72: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109f74: 75 04 jne 109f7a <_Heap_Initialize+0x1a> <== NOT EXECUTED 109f76: b1 04 mov $0x4,%cl <== NOT EXECUTED 109f78: eb 0c jmp 109f86 <_Heap_Initialize+0x26> <== NOT EXECUTED * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information */ 109f7a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109f7c: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 109f7f: 74 05 je 109f86 <_Heap_Initialize+0x26> <== NOT EXECUTED 109f81: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 109f84: 29 c1 sub %eax,%ecx <== NOT EXECUTED /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 109f86: 8d 5f 08 lea 0x8(%edi),%ebx <== NOT EXECUTED 109f89: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109f8b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109f8d: f7 f1 div %ecx <== NOT EXECUTED 109f8f: 85 d2 test %edx,%edx <== NOT EXECUTED 109f91: 74 05 je 109f98 <_Heap_Initialize+0x38> <== NOT EXECUTED 109f93: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 109f96: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 109f98: 83 eb 08 sub $0x8,%ebx <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 109f9b: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 109fa0: 31 d2 xor %edx,%edx <== NOT EXECUTED 109fa2: f7 f1 div %ecx <== NOT EXECUTED */ 109fa4: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 109fa9: 85 d2 test %edx,%edx <== NOT EXECUTED 109fab: 74 05 je 109fb2 <_Heap_Initialize+0x52> <== NOT EXECUTED 109fad: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 109fb0: 29 d0 sub %edx,%eax <== NOT EXECUTED 109fb2: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 109fb5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109fb7: 29 f8 sub %edi,%eax <== NOT EXECUTED 109fb9: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 109fbc: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 109fbf: 0f 82 a0 00 00 00 jb 10a065 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 109fc5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 109fc8: 29 c2 sub %eax,%edx <== NOT EXECUTED 109fca: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 109fcd: 89 d0 mov %edx,%eax <== NOT EXECUTED 109fcf: 31 d2 xor %edx,%edx <== NOT EXECUTED 109fd1: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 109fd3: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109fd6: 29 d0 sub %edx,%eax <== NOT EXECUTED 109fd8: 89 c2 mov %eax,%edx <== NOT EXECUTED 109fda: 0f 84 85 00 00 00 je 10a065 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 109fe0: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED the_heap->begin = starting_address; 109fe3: 89 7e 18 mov %edi,0x18(%esi) <== NOT EXECUTED the_heap->end = starting_address + size; 109fe6: 03 7d 10 add 0x10(%ebp),%edi <== NOT EXECUTED 109fe9: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 109fec: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 109fee: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 109ff1: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 109ff4: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 109ff7: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 109ffa: 89 5e 08 mov %ebx,0x8(%esi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 109ffd: 89 5e 0c mov %ebx,0xc(%esi) <== NOT EXECUTED the_heap->start = the_block; 10a000: 89 5e 20 mov %ebx,0x20(%esi) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a003: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 10a006: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10a009: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = page_size; 10a00b: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10a00e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a011: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED stats->free_size = the_size; 10a014: 89 56 30 mov %edx,0x30(%esi) <== NOT EXECUTED stats->min_free_size = the_size; 10a017: 89 56 34 mov %edx,0x34(%esi) <== NOT EXECUTED stats->free_blocks = 1; 10a01a: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) <== NOT EXECUTED stats->max_free_blocks = 1; 10a021: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi) <== NOT EXECUTED stats->used_blocks = 0; 10a028: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) <== NOT EXECUTED stats->max_search = 0; 10a02f: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) <== NOT EXECUTED stats->allocs = 0; 10a036: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED stats->searches = 0; 10a03d: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) <== NOT EXECUTED stats->frees = 0; 10a044: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED stats->resizes = 0; 10a04b: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED stats->instance = instance++; 10a052: a1 b4 c7 11 00 mov 0x11c7b4,%eax <== NOT EXECUTED 10a057: 89 46 28 mov %eax,0x28(%esi) <== NOT EXECUTED 10a05a: 40 inc %eax <== NOT EXECUTED 10a05b: a3 b4 c7 11 00 mov %eax,0x11c7b4 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10a060: 8d 42 fc lea -0x4(%edx),%eax <== NOT EXECUTED 10a063: eb 02 jmp 10a067 <_Heap_Initialize+0x107> <== NOT EXECUTED 10a065: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10a067: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a06a: 5b pop %ebx <== NOT EXECUTED 10a06b: 5e pop %esi <== NOT EXECUTED 10a06c: 5f pop %edi <== NOT EXECUTED 10a06d: c9 leave <== NOT EXECUTED 10a06e: c3 ret <== NOT EXECUTED 00114fe4 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 114fe4: 55 push %ebp <== NOT EXECUTED 114fe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114fe7: 57 push %edi <== NOT EXECUTED 114fe8: 56 push %esi <== NOT EXECUTED 114fe9: 53 push %ebx <== NOT EXECUTED 114fea: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED Heap_Block *next_next_block; uint32_t old_block_size; uint32_t old_user_size; uint32_t prev_used_flag; Heap_Statistics *const stats = &the_heap->stats; uint32_t const min_block_size = the_heap->min_block_size; 114fed: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ff0: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 114ff3: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 114ff6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 114ff9: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED *old_mem_size = 0; 114ffc: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 114fff: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED *avail_mem_size = 0; 115005: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115008: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11500e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 115011: 83 ea 08 sub $0x8,%edx <== NOT EXECUTED 115014: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 115017: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11501a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11501d: 31 d2 xor %edx,%edx <== NOT EXECUTED 11501f: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 115022: 29 55 f0 sub %edx,-0x10(%ebp) <== NOT EXECUTED 115025: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115027: 8b 49 24 mov 0x24(%ecx),%ecx <== NOT EXECUTED 11502a: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 11502d: 39 5d f0 cmp %ebx,-0x10(%ebp) <== NOT EXECUTED 115030: 0f 93 c2 setae %dl <== NOT EXECUTED 115033: 39 4d f0 cmp %ecx,-0x10(%ebp) <== NOT EXECUTED 115036: 0f 96 c0 setbe %al <== NOT EXECUTED 115039: 84 d0 test %dl,%al <== NOT EXECUTED 11503b: 0f 84 7e 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 115041: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115044: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED 115047: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 11504a: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 11504d: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 115050: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 115053: 01 d7 add %edx,%edi <== NOT EXECUTED old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 115055: 39 df cmp %ebx,%edi <== NOT EXECUTED 115057: 0f 93 c2 setae %dl <== NOT EXECUTED 11505a: 39 cf cmp %ecx,%edi <== NOT EXECUTED 11505c: 0f 96 c0 setbe %al <== NOT EXECUTED 11505f: 84 d0 test %dl,%al <== NOT EXECUTED 115061: 0f 84 58 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115067: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 11506a: a8 01 test $0x1,%al <== NOT EXECUTED 11506c: 0f 84 4d 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115072: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115075: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 115078: 01 f8 add %edi,%eax <== NOT EXECUTED 11507a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 11507d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 115082: 39 cf cmp %ecx,%edi <== NOT EXECUTED 115084: 74 09 je 11508f <_Heap_Resize_block+0xab> <== NOT EXECUTED 115086: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 115089: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 11508c: 83 e0 01 and $0x1,%eax <== NOT EXECUTED _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 11508f: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 115092: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 115095: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 115098: 88 c1 mov %al,%cl <== NOT EXECUTED _Heap_Is_prev_used(next_next_block); /* See _Heap_Size_of_user_area() source for explanations */ old_user_size = _Addresses_Subtract(next_block, starting_address) 11509a: 89 f8 mov %edi,%eax <== NOT EXECUTED 11509c: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 11509f: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 1150a2: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1150a5: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 1150a7: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 1150aa: 76 50 jbe 1150fc <_Heap_Resize_block+0x118> <== NOT EXECUTED /* Need to extend the block: allocate part of the next block and then merge 'the_block' and allocated block together. */ if (next_is_used) /* Next block is in use, -- no way to extend */ 1150ac: 84 c9 test %cl,%cl <== NOT EXECUTED 1150ae: 0f 85 12 01 00 00 jne 1151c6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 1150b4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1150b7: 29 c1 sub %eax,%ecx <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 1150b9: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1150bb: 31 d2 xor %edx,%edx <== NOT EXECUTED 1150bd: f7 f6 div %esi <== NOT EXECUTED */ 1150bf: 85 d2 test %edx,%edx <== NOT EXECUTED 1150c1: 74 04 je 1150c7 <_Heap_Resize_block+0xe3> <== NOT EXECUTED 1150c3: 01 f1 add %esi,%ecx <== NOT EXECUTED 1150c5: 29 d1 sub %edx,%ecx <== NOT EXECUTED 1150c7: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1150c9: 3b 4d ec cmp -0x14(%ebp),%ecx <== NOT EXECUTED 1150cc: 73 03 jae 1150d1 <_Heap_Resize_block+0xed> <== NOT EXECUTED 1150ce: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 1150d1: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 1150d4: 0f 87 ec 00 00 00 ja 1151c6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 1150da: 53 push %ebx <== NOT EXECUTED 1150db: 50 push %eax <== NOT EXECUTED 1150dc: 57 push %edi <== NOT EXECUTED 1150dd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1150e0: e8 c7 4f ff ff call 10a0ac <_Heap_Block_allocate> <== NOT EXECUTED _Heap_Block_allocate(the_heap, next_block, add_block_size); /* Merge two subsequent blocks */ the_block->size = (old_block_size + add_block_size) | prev_used_flag; 1150e5: 03 45 e4 add -0x1c(%ebp),%eax <== NOT EXECUTED 1150e8: 0b 45 e8 or -0x18(%ebp),%eax <== NOT EXECUTED 1150eb: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 1150ee: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED --stats->used_blocks; 1150f1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1150f4: ff 49 40 decl 0x40(%ecx) <== NOT EXECUTED 1150f7: e9 b6 00 00 00 jmp 1151b2 <_Heap_Resize_block+0x1ce> <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 1150fc: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1150fe: 2b 5d 10 sub 0x10(%ebp),%ebx <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 115101: 89 d8 mov %ebx,%eax <== NOT EXECUTED 115103: 31 d2 xor %edx,%edx <== NOT EXECUTED 115105: f7 f6 div %esi <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 115107: 89 de mov %ebx,%esi <== NOT EXECUTED 115109: 29 d6 sub %edx,%esi <== NOT EXECUTED 11510b: 0f 84 a4 00 00 00 je 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED /* To free some memory the block should be shortened so that it can can hold 'size' user bytes and still remain not shorter than 'min_block_size'. */ uint32_t new_block_size = old_block_size - free_block_size; 115111: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED 115114: 29 f3 sub %esi,%ebx <== NOT EXECUTED if (new_block_size < min_block_size) { 115116: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 115119: 73 16 jae 115131 <_Heap_Resize_block+0x14d> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 11511b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11511e: 29 d8 sub %ebx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 115120: 29 c6 sub %eax,%esi <== NOT EXECUTED 115122: 75 0b jne 11512f <_Heap_Resize_block+0x14b> <== NOT EXECUTED ++stats->resizes; 115124: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115127: ff 42 54 incl 0x54(%edx) <== NOT EXECUTED 11512a: e9 8c 00 00 00 jmp 1151bb <_Heap_Resize_block+0x1d7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 11512f: 01 c3 add %eax,%ebx <== 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) { 115131: 84 c9 test %cl,%cl <== NOT EXECUTED 115133: 75 43 jne 115178 <_Heap_Resize_block+0x194> <== NOT EXECUTED 115135: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115138: 01 da add %ebx,%edx <== NOT EXECUTED /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 11513a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11513d: 8d 0c 06 lea (%esi,%eax,1),%ecx <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 115140: 0b 5d e8 or -0x18(%ebp),%ebx <== NOT EXECUTED 115143: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 115146: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 115149: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11514b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 11514e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 115151: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 115154: 89 08 mov %ecx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 115156: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 115159: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 11515c: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED ); 11515f: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 115162: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 115165: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 115168: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11516b: 01 72 30 add %esi,0x30(%edx) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 11516e: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 115171: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115174: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 115176: eb 3d jmp 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 115178: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED 11517b: 72 38 jb 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 11517d: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED 115180: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 115183: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115186: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED 115189: 89 d0 mov %edx,%eax <== NOT EXECUTED 11518b: 01 d8 add %ebx,%eax <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 11518d: 89 f2 mov %esi,%edx <== NOT EXECUTED 11518f: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 115192: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 115195: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115198: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 11519b: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 11519e: 51 push %ecx <== NOT EXECUTED 11519f: 51 push %ecx <== NOT EXECUTED 1151a0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 1151a3: 50 push %eax <== NOT EXECUTED 1151a4: 52 push %edx <== NOT EXECUTED 1151a5: e8 5e 87 ff ff call 10d908 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 1151aa: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED 1151ad: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 1151b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 1151b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } ++stats->resizes; 1151b5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1151b8: ff 40 54 incl 0x54(%eax) <== NOT EXECUTED 1151bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1151bd: eb 0c jmp 1151cb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 1151bf: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 1151c4: eb 05 jmp 1151cb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED 1151c6: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } 1151cb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1151ce: 5b pop %ebx <== NOT EXECUTED 1151cf: 5e pop %esi <== NOT EXECUTED 1151d0: 5f pop %edi <== NOT EXECUTED 1151d1: c9 leave <== NOT EXECUTED 1151d2: c3 ret <== NOT EXECUTED 001151d4 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1151d4: 55 push %ebp <== NOT EXECUTED 1151d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1151d7: 57 push %edi <== NOT EXECUTED 1151d8: 56 push %esi <== NOT EXECUTED 1151d9: 53 push %ebx <== NOT EXECUTED 1151da: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 1151dd: 8b 7e 24 mov 0x24(%esi),%edi <== NOT EXECUTED 1151e0: 8b 5e 20 mov 0x20(%esi),%ebx <== NOT EXECUTED 1151e3: 39 5d 0c cmp %ebx,0xc(%ebp) <== NOT EXECUTED 1151e6: 0f 93 c2 setae %dl <== NOT EXECUTED 1151e9: 39 7d 0c cmp %edi,0xc(%ebp) <== NOT EXECUTED 1151ec: 0f 96 c0 setbe %al <== NOT EXECUTED 1151ef: 84 d0 test %dl,%al <== NOT EXECUTED 1151f1: 74 49 je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 1151f3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1151f6: 83 e9 08 sub $0x8,%ecx <== NOT EXECUTED 1151f9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1151fc: 31 d2 xor %edx,%edx <== NOT EXECUTED 1151fe: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 115201: 29 d1 sub %edx,%ecx <== NOT EXECUTED return( FALSE ); _Heap_Start_of_block( the_heap, starting_address, &the_block ); _HAssert(_Heap_Is_block_in( the_heap, the_block )); if ( !_Heap_Is_block_in( the_heap, the_block ) ) 115203: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 115205: 0f 93 c2 setae %dl <== NOT EXECUTED 115208: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 11520a: 0f 96 c0 setbe %al <== NOT EXECUTED 11520d: 84 d0 test %dl,%al <== NOT EXECUTED 11520f: 74 2b je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115211: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 115214: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115217: 01 c1 add %eax,%ecx <== NOT EXECUTED the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); _HAssert(_Heap_Is_block_in( the_heap, next_block )); _HAssert(_Heap_Is_prev_used( next_block )); if ( 115219: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 11521b: 0f 93 c2 setae %dl <== NOT EXECUTED 11521e: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 115220: 0f 96 c0 setbe %al <== NOT EXECUTED 115223: 84 d0 test %dl,%al <== NOT EXECUTED 115225: 74 15 je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115227: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 11522b: 74 0f je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED and then add correction equal to the offset of the 'size' field of the 'Heap_Block' structure. The correction is due to the fact that 'prev_size' field of the next block is actually used as user accessible area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) 11522d: 2b 4d 0c sub 0xc(%ebp),%ecx <== NOT EXECUTED 115230: 8d 51 04 lea 0x4(%ecx),%edx <== NOT EXECUTED 115233: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115236: 89 10 mov %edx,(%eax) <== NOT EXECUTED 115238: b0 01 mov $0x1,%al <== NOT EXECUTED 11523a: eb 02 jmp 11523e <_Heap_Size_of_user_area+0x6a> <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 11523c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11523e: 5b pop %ebx <== NOT EXECUTED 11523f: 5e pop %esi <== NOT EXECUTED 115240: 5f pop %edi <== NOT EXECUTED 115241: c9 leave <== NOT EXECUTED 115242: c3 ret <== NOT EXECUTED 0010fa2c <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10fa2c: 55 push %ebp <== NOT EXECUTED 10fa2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa2f: 57 push %edi <== NOT EXECUTED 10fa30: 56 push %esi <== NOT EXECUTED 10fa31: 53 push %ebx <== NOT EXECUTED 10fa32: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10fa35: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 10fa38: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fa3b: 8b 70 20 mov 0x20(%eax),%esi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 10fa3e: 8b 50 24 mov 0x24(%eax),%edx <== NOT EXECUTED 10fa41: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 10fa44: 85 db test %ebx,%ebx <== NOT EXECUTED 10fa46: 79 03 jns 10fa4b <_Heap_Walk+0x1f> <== NOT EXECUTED source = the_heap->stats.instance; 10fa48: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 10fa4b: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10fa4d: f6 46 04 01 testb $0x1,0x4(%esi) <== NOT EXECUTED 10fa51: 75 15 jne 10fa68 <_Heap_Walk+0x3c> <== NOT EXECUTED printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 10fa53: 50 push %eax <== NOT EXECUTED 10fa54: 50 push %eax <== NOT EXECUTED 10fa55: 53 push %ebx <== NOT EXECUTED 10fa56: 68 38 aa 11 00 push $0x11aa38 <== NOT EXECUTED 10fa5b: e8 4a 8a ff ff call 1084aa <== NOT EXECUTED 10fa60: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fa65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (the_block->prev_size != the_heap->page_size) { 10fa68: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10fa6a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fa6d: 3b 47 10 cmp 0x10(%edi),%eax <== NOT EXECUTED 10fa70: 0f 84 38 01 00 00 je 10fbae <_Heap_Walk+0x182> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 10fa76: 50 push %eax <== NOT EXECUTED 10fa77: 50 push %eax <== NOT EXECUTED 10fa78: 53 push %ebx <== NOT EXECUTED 10fa79: 68 6e aa 11 00 push $0x11aa6e <== NOT EXECUTED 10fa7e: e8 27 8a ff ff call 1084aa <== NOT EXECUTED 10fa83: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fa88: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa8b: e9 1e 01 00 00 jmp 10fbae <_Heap_Walk+0x182> <== NOT EXECUTED 10fa90: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10fa93: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10fa96: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10fa99: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10fa9c: 01 f0 add %esi,%eax <== NOT EXECUTED 10fa9e: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED printk(" prev_size %d", the_block->prev_size); else printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { 10faa1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10faa4: 3b 42 20 cmp 0x20(%edx),%eax <== NOT EXECUTED 10faa7: 0f 93 c2 setae %dl <== NOT EXECUTED 10faaa: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10faad: 3b 47 24 cmp 0x24(%edi),%eax <== NOT EXECUTED 10fab0: 0f 96 c0 setbe %al <== NOT EXECUTED 10fab3: 84 d0 test %dl,%al <== NOT EXECUTED 10fab5: 75 0f jne 10fac6 <_Heap_Walk+0x9a> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 10fab7: 50 push %eax <== NOT EXECUTED 10fab8: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10fabb: 53 push %ebx <== NOT EXECUTED 10fabc: 68 a0 aa 11 00 push $0x11aaa0 <== NOT EXECUTED 10fac1: e9 d7 00 00 00 jmp 10fb9d <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 10fac6: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10fac9: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 10facd: 0f 85 85 00 00 00 jne 10fb58 <_Heap_Walk+0x12c> <== NOT EXECUTED if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 10fad3: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fad6: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 10fad8: 74 15 je 10faef <_Heap_Walk+0xc3> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 10fada: 50 push %eax <== NOT EXECUTED 10fadb: 50 push %eax <== NOT EXECUTED 10fadc: 53 push %ebx <== NOT EXECUTED 10fadd: 68 c3 aa 11 00 push $0x11aac3 <== NOT EXECUTED 10fae2: e8 c3 89 ff ff call 1084aa <== NOT EXECUTED 10fae7: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10faec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 10faef: f6 45 f0 01 testb $0x1,-0x10(%ebp) <== NOT EXECUTED 10faf3: 75 29 jne 10fb1e <_Heap_Walk+0xf2> <== NOT EXECUTED if (do_dump || error) printk("\n"); 10faf5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10faf7: 74 10 je 10fb09 <_Heap_Walk+0xdd> <== NOT EXECUTED 10faf9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fafc: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb01: e8 a4 89 ff ff call 1084aa <== NOT EXECUTED 10fb06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 10fb09: 57 push %edi <== NOT EXECUTED 10fb0a: 57 push %edi <== NOT EXECUTED 10fb0b: 53 push %ebx <== NOT EXECUTED 10fb0c: 68 ee aa 11 00 push $0x11aaee <== NOT EXECUTED 10fb11: e8 94 89 ff ff call 1084aa <== NOT EXECUTED 10fb16: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fb1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10fb1e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fb21: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10fb24: eb 03 jmp 10fb29 <_Heap_Walk+0xfd> <== NOT EXECUTED } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; 10fb26: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 10fb29: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10fb2b: 74 2b je 10fb58 <_Heap_Walk+0x12c> <== NOT EXECUTED 10fb2d: 3b 45 08 cmp 0x8(%ebp),%eax <== NOT EXECUTED 10fb30: 75 f4 jne 10fb26 <_Heap_Walk+0xfa> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 10fb32: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fb34: 74 10 je 10fb46 <_Heap_Walk+0x11a> <== NOT EXECUTED 10fb36: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fb39: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb3e: e8 67 89 ff ff call 1084aa <== NOT EXECUTED 10fb43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 10fb46: 51 push %ecx <== NOT EXECUTED 10fb47: 51 push %ecx <== NOT EXECUTED 10fb48: 53 push %ebx <== NOT EXECUTED 10fb49: 68 18 ab 11 00 push $0x11ab18 <== NOT EXECUTED 10fb4e: e8 57 89 ff ff call 1084aa <== NOT EXECUTED 10fb53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fb56: eb 04 jmp 10fb5c <_Heap_Walk+0x130> <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 10fb58: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fb5a: 74 15 je 10fb71 <_Heap_Walk+0x145> <== NOT EXECUTED 10fb5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fb5f: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb64: e8 41 89 ff ff call 1084aa <== NOT EXECUTED 10fb69: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fb6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 10fb71: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fb74: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fb77: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10fb7a: 73 0a jae 10fb86 <_Heap_Walk+0x15a> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 10fb7c: 52 push %edx <== NOT EXECUTED 10fb7d: 52 push %edx <== NOT EXECUTED 10fb7e: 53 push %ebx <== NOT EXECUTED 10fb7f: 68 41 ab 11 00 push $0x11ab41 <== NOT EXECUTED 10fb84: eb 17 jmp 10fb9d <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 10fb86: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fb89: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fb8c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fb8e: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10fb91: 85 d2 test %edx,%edx <== NOT EXECUTED 10fb93: 74 12 je 10fba7 <_Heap_Walk+0x17b> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); 10fb95: 50 push %eax <== NOT EXECUTED 10fb96: 50 push %eax <== NOT EXECUTED 10fb97: 53 push %ebx <== NOT EXECUTED 10fb98: 68 64 ab 11 00 push $0x11ab64 <== NOT EXECUTED 10fb9d: e8 08 89 ff ff call 1084aa <== NOT EXECUTED 10fba2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fba5: eb 12 jmp 10fbb9 <_Heap_Walk+0x18d> <== NOT EXECUTED error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 10fba7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fba9: 75 0e jne 10fbb9 <_Heap_Walk+0x18d> <== NOT EXECUTED break; 10fbab: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED if (the_block->prev_size != the_heap->page_size) { printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); error = 1; } while ( the_block != end ) { 10fbae: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 10fbb1: 0f 85 d9 fe ff ff jne 10fa90 <_Heap_Walk+0x64> <== NOT EXECUTED 10fbb7: eb 17 jmp 10fbd0 <_Heap_Walk+0x1a4> <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 10fbb9: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10fbbc: 56 push %esi <== NOT EXECUTED 10fbbd: 53 push %ebx <== NOT EXECUTED 10fbbe: 68 88 ab 11 00 push $0x11ab88 <== NOT EXECUTED 10fbc3: e8 e2 88 ff ff call 1084aa <== NOT EXECUTED 10fbc8: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fbcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fbd0: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10fbd3: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 10fbd6: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10fbd9: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 10fbdc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10fbde: 74 15 je 10fbf5 <_Heap_Walk+0x1c9> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 10fbe0: 52 push %edx <== NOT EXECUTED 10fbe1: 50 push %eax <== NOT EXECUTED 10fbe2: 53 push %ebx <== NOT EXECUTED 10fbe3: 68 c3 ab 11 00 push $0x11abc3 <== NOT EXECUTED 10fbe8: e8 bd 88 ff ff call 1084aa <== NOT EXECUTED 10fbed: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fbf2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fbf5: 88 c8 mov %cl,%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 10fbf7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fbfa: 5b pop %ebx <== NOT EXECUTED 10fbfb: 5e pop %esi <== NOT EXECUTED 10fbfc: 5f pop %edi <== NOT EXECUTED 10fbfd: c9 leave <== NOT EXECUTED 10fbfe: c3 ret <== NOT EXECUTED 00109774 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 109774: 55 push %ebp <== NOT EXECUTED 109775: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109777: 53 push %ebx <== NOT EXECUTED 109778: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10977b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10977d: eb 0f jmp 10978e <_IO_Initialize_all_drivers+0x1a> <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) (void) rtems_io_initialize( major, 0, NULL ); 10977f: 50 push %eax <== NOT EXECUTED 109780: 6a 00 push $0x0 <== NOT EXECUTED 109782: 6a 00 push $0x0 <== NOT EXECUTED 109784: 53 push %ebx <== NOT EXECUTED 109785: e8 86 3e 00 00 call 10d610 <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10978a: 43 inc %ebx <== NOT EXECUTED 10978b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10978e: 3b 1d 2c cd 11 00 cmp 0x11cd2c,%ebx <== NOT EXECUTED 109794: 72 e9 jb 10977f <_IO_Initialize_all_drivers+0xb> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 109796: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109799: c9 leave <== NOT EXECUTED 10979a: c3 ret <== NOT EXECUTED 0010979b <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10979b: 55 push %ebp <== NOT EXECUTED 10979c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10979e: 57 push %edi <== NOT EXECUTED 10979f: 56 push %esi <== NOT EXECUTED 1097a0: 53 push %ebx <== NOT EXECUTED 1097a1: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1097a4: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 1097a7: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 1097aa: 76 2f jbe 1097db <_IO_Manager_initialization+0x40> <== NOT EXECUTED /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 1097ac: 6b de 18 imul $0x18,%esi,%ebx <== NOT EXECUTED 1097af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097b2: 53 push %ebx <== NOT EXECUTED 1097b3: e8 ba 25 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 1097b8: 89 c7 mov %eax,%edi <== NOT EXECUTED 1097ba: a3 30 cd 11 00 mov %eax,0x11cd30 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 1097bf: 89 35 2c cd 11 00 mov %esi,0x11cd2c <== NOT EXECUTED memset( 1097c5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097c7: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1097c9: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1097cb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1097ce: 8b 15 30 cd 11 00 mov 0x11cd30,%edx <== NOT EXECUTED 1097d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1097d9: eb 25 jmp 109800 <_IO_Manager_initialization+0x65> <== NOT EXECUTED * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 1097db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1097de: a3 30 cd 11 00 mov %eax,0x11cd30 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 1097e3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1097e6: 89 0d 2c cd 11 00 mov %ecx,0x11cd2c <== NOT EXECUTED 1097ec: eb 17 jmp 109805 <_IO_Manager_initialization+0x6a> <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 1097ee: 89 d7 mov %edx,%edi <== NOT EXECUTED 1097f0: 89 de mov %ebx,%esi <== NOT EXECUTED 1097f2: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 1097f7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 1097f9: 40 inc %eax <== NOT EXECUTED 1097fa: 83 c3 18 add $0x18,%ebx <== NOT EXECUTED 1097fd: 83 c2 18 add $0x18,%edx <== NOT EXECUTED 109800: 3b 45 0c cmp 0xc(%ebp),%eax <== NOT EXECUTED 109803: 72 e9 jb 1097ee <_IO_Manager_initialization+0x53> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 109805: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109808: 5b pop %ebx <== NOT EXECUTED 109809: 5e pop %esi <== NOT EXECUTED 10980a: 5f pop %edi <== NOT EXECUTED 10980b: c9 leave <== NOT EXECUTED 10980c: c3 ret <== NOT EXECUTED 0010a168 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10a168: 55 push %ebp <== NOT EXECUTED 10a169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a16b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10a16e: c6 05 54 cb 11 00 00 movb $0x0,0x11cb54 <== NOT EXECUTED _ISR_Nest_level = 0; 10a175: c7 05 9c ca 11 00 00 movl $0x0,0x11ca9c <== NOT EXECUTED 10a17c: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10a17f: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10a184: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10a187: 3b 05 80 86 11 00 cmp 0x118680,%eax <== NOT EXECUTED 10a18d: 73 0c jae 10a19b <_ISR_Handler_initialization+0x33> <== NOT EXECUTED _Internal_error_Occurred( 10a18f: 50 push %eax <== NOT EXECUTED 10a190: 6a 05 push $0x5 <== NOT EXECUTED 10a192: 6a 01 push $0x1 <== NOT EXECUTED 10a194: 6a 00 push $0x0 <== NOT EXECUTED 10a196: e8 8d ff ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error( 10a19b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a19e: 50 push %eax <== NOT EXECUTED 10a19f: e8 ce 1b 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a1a4: a3 10 ca 11 00 mov %eax,0x11ca10 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10a1a9: 8b 15 98 ca 11 00 mov 0x11ca98,%edx <== NOT EXECUTED 10a1af: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10a1b2: a3 d0 c9 11 00 mov %eax,0x11c9d0 <== NOT EXECUTED 10a1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10a1ba: c9 leave <== NOT EXECUTED 10a1bb: c3 ret <== NOT EXECUTED 0010a128 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10a128: 55 push %ebp <== NOT EXECUTED 10a129: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12b: 53 push %ebx <== NOT EXECUTED 10a12c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a12f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a132: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a135: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10a138: 89 15 a8 ca 11 00 mov %edx,0x11caa8 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10a13e: a2 ac ca 11 00 mov %al,0x11caac <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10a143: 89 1d b0 ca 11 00 mov %ebx,0x11cab0 <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10a149: 53 push %ebx <== NOT EXECUTED 10a14a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a14d: 50 push %eax <== NOT EXECUTED 10a14e: 52 push %edx <== NOT EXECUTED 10a14f: e8 eb 18 00 00 call 10ba3f <_User_extensions_Fatal> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10a154: c7 05 a0 cb 11 00 05 movl $0x5,0x11cba0 <== NOT EXECUTED 10a15b: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10a15e: fa cli <== NOT EXECUTED 10a15f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a161: f4 hlt <== NOT EXECUTED 10a162: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a165: eb fe jmp 10a165 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010d2a0 <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10d2a0: 55 push %ebp <== NOT EXECUTED 10d2a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10d2a3: c9 leave <== NOT EXECUTED 10d2a4: c3 ret <== NOT EXECUTED 00120db8 <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 120db8: 55 push %ebp <== NOT EXECUTED 120db9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120dbb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 120dbe: 68 cc 9f 15 00 push $0x159fcc <== NOT EXECUTED 120dc3: e8 ec dd fe ff call 10ebb4 <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 120dc8: c9 leave <== NOT EXECUTED 120dc9: c3 ret <== NOT EXECUTED 0010d2a8 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10d2a8: 55 push %ebp <== NOT EXECUTED 10d2a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2ae: 6a 04 push $0x4 <== NOT EXECUTED 10d2b0: 6a 00 push $0x0 <== NOT EXECUTED 10d2b2: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10d2b7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d2ba: 6a 04 push $0x4 <== NOT EXECUTED 10d2bc: 6a 02 push $0x2 <== NOT EXECUTED 10d2be: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 10d2c3: e8 90 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d2c8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10d2cb: c9 leave <== NOT EXECUTED 10d2cc: c3 ret <== NOT EXECUTED 00108f04 <_Message_queue_Translate_core_message_queue_return_code>: }; rtems_status_code _Message_queue_Translate_core_message_queue_return_code ( uint32_t status ) { 108f04: 55 push %ebp <== NOT EXECUTED 108f05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f07: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108f0a: 8b 04 85 4c a9 11 00 mov 0x11a94c(,%eax,4),%eax <== NOT EXECUTED if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ) return RTEMS_INTERNAL_ERROR; #endif return _Message_queue_Translate_core_return_code_[status]; } 108f11: c9 leave <== NOT EXECUTED 108f12: c3 ret <== NOT EXECUTED 0010da70 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10da70: 55 push %ebp <== NOT EXECUTED 10da71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da73: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED switch (api) { 10da76: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10da7b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10da7e: 74 1b je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED 10da80: 77 05 ja 10da87 <_Objects_API_maximum_class+0x17> <== NOT EXECUTED 10da82: b0 02 mov $0x2,%al <== NOT EXECUTED 10da84: 4a dec %edx <== NOT EXECUTED 10da85: eb 0f jmp 10da96 <_Objects_API_maximum_class+0x26> <== NOT EXECUTED 10da87: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10da8c: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10da8f: 74 0a je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED case OBJECTS_INTERNAL_API: return OBJECTS_INTERNAL_CLASSES_LAST; case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; 10da91: b0 08 mov $0x8,%al <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10da93: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10da96: 74 03 je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; case OBJECTS_ITRON_API: return OBJECTS_ITRON_CLASSES_LAST; 10da98: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10da9b: c9 leave <== NOT EXECUTED 10da9c: c3 ret <== NOT EXECUTED 0010a1bc <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10a1bc: 55 push %ebp <== NOT EXECUTED 10a1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bf: 56 push %esi <== NOT EXECUTED 10a1c0: 53 push %ebx <== NOT EXECUTED 10a1c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10a1c4: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a1c6: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10a1ca: 74 59 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10a1cc: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10a1cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1d2: 56 push %esi <== NOT EXECUTED 10a1d3: e8 6c f8 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a1d8: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10a1da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1dd: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a1e1: 74 42 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10a1e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1e5: 75 1a jne 10a201 <_Objects_Allocate+0x45> <== NOT EXECUTED _Objects_Extend_information( information ); 10a1e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1ea: 53 push %ebx <== NOT EXECUTED 10a1eb: e8 64 00 00 00 call 10a254 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10a1f0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a1f3: e8 4c f8 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a1f8: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10a1fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1fd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1ff: 74 24 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED uint32_t block; block = _Objects_Get_index( the_object->id ) - 10a201: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10a204: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a209: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a20c: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a212: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10a214: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a216: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a219: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a21c: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a21f: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10a221: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10a225: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a227: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a22a: 5b pop %ebx <== NOT EXECUTED 10a22b: 5e pop %esi <== NOT EXECUTED 10a22c: c9 leave <== NOT EXECUTED 10a22d: c3 ret <== NOT EXECUTED 0010a230 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10a230: 55 push %ebp <== NOT EXECUTED 10a231: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a233: 53 push %ebx <== NOT EXECUTED 10a234: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a237: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a23a: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10a23e: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a241: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10a248: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10a24b: 5b pop %ebx <== NOT EXECUTED 10a24c: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10a24d: e9 c2 04 00 00 jmp 10a714 <_Objects_Namespace_remove> <== NOT EXECUTED 0010a254 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10a254: 55 push %ebp <== NOT EXECUTED 10a255: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a257: 57 push %edi <== NOT EXECUTED 10a258: 56 push %esi <== NOT EXECUTED 10a259: 53 push %ebx <== NOT EXECUTED 10a25a: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 10a25d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a260: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a263: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a268: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 10a26b: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a26f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a271: 73 13 jae 10a286 <_Objects_Extend_information+0x32> <== NOT EXECUTED 10a273: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a276: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) <== NOT EXECUTED 10a27d: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a284: eb 35 jmp 10a2bb <_Objects_Extend_information+0x67> <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; 10a286: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED 10a289: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a28b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a28d: f7 f7 div %edi <== NOT EXECUTED 10a28f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10a291: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED 10a294: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10a297: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a29a: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a2a1: eb 13 jmp 10a2b6 <_Objects_Extend_information+0x62> <== NOT EXECUTED for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 10a2a3: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a2a6: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a2a9: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a2ad: 74 0c je 10a2bb <_Objects_Extend_information+0x67> <== NOT EXECUTED break; else index_base += information->allocation_size; 10a2af: 01 7d c4 add %edi,-0x3c(%ebp) <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10a2b2: 42 inc %edx <== NOT EXECUTED 10a2b3: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 10a2b6: 39 75 c0 cmp %esi,-0x40(%ebp) <== NOT EXECUTED 10a2b9: 72 e8 jb 10a2a3 <_Objects_Extend_information+0x4f> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10a2bb: 39 4d c4 cmp %ecx,-0x3c(%ebp) <== NOT EXECUTED 10a2be: 0f 82 30 01 00 00 jb 10a3f4 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED /* * Up the block count and maximum */ block_count++; 10a2c4: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED 10a2c7: 46 inc %esi <== NOT EXECUTED maximum = information->maximum + information->allocation_size; 10a2c8: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a2cb: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10a2ce: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a2d2: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 10a2d5: 8d 14 39 lea (%ecx,%edi,1),%edx <== NOT EXECUTED 10a2d8: 74 21 je 10a2fb <_Objects_Extend_information+0xa7> <== NOT EXECUTED object_blocks = (void**) 10a2da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2dd: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a2e0: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a2e3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a2e6: 50 push %eax <== NOT EXECUTED 10a2e7: e8 71 1a 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10a2ec: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10a2ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a2f2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a2f4: 75 1d jne 10a313 <_Objects_Extend_information+0xbf> <== NOT EXECUTED 10a2f6: e9 c9 01 00 00 jmp 10a4c4 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { object_blocks = (void**) 10a2fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2fe: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a301: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a304: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a307: 50 push %eax <== NOT EXECUTED 10a308: e8 65 1a 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a30d: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED 10a310: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10a313: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 10a316: 8d 04 b0 lea (%eax,%esi,4),%eax <== NOT EXECUTED 10a319: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a31c: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a31f: 8d 34 f2 lea (%edx,%esi,8),%esi <== NOT EXECUTED 10a322: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10a325: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10a329: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a32b: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10a32e: 76 39 jbe 10a369 <_Objects_Extend_information+0x115> <== NOT EXECUTED /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 10a330: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 10a333: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a336: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a339: 8b 7d a0 mov -0x60(%ebp),%edi <== NOT EXECUTED 10a33c: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a33e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10a340: 8b 73 30 mov 0x30(%ebx),%esi <== NOT EXECUTED 10a343: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a346: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a348: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10a34a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a34e: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10a351: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10a354: 8b 73 1c mov 0x1c(%ebx),%esi <== NOT EXECUTED 10a357: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10a35a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a35c: eb 10 jmp 10a36e <_Objects_Extend_information+0x11a> <== NOT EXECUTED /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10a35e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a361: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10a368: 42 inc %edx <== NOT EXECUTED 10a369: 3b 55 c8 cmp -0x38(%ebp),%edx <== NOT EXECUTED 10a36c: 72 f0 jb 10a35e <_Objects_Extend_information+0x10a> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10a36e: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED 10a371: 8b 4d a0 mov -0x60(%ebp),%ecx <== NOT EXECUTED 10a374: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10a37b: 8b 75 cc mov -0x34(%ebp),%esi <== NOT EXECUTED 10a37e: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a385: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10a388: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a38b: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED 10a38e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a391: 8d 14 b8 lea (%eax,%edi,4),%edx <== NOT EXECUTED 10a394: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a396: eb 0a jmp 10a3a2 <_Objects_Extend_information+0x14e> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10a398: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10a39e: 40 inc %eax <== NOT EXECUTED 10a39f: 83 c2 04 add $0x4,%edx <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a3a2: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10a3a4: 72 f2 jb 10a398 <_Objects_Extend_information+0x144> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10a3a6: 9c pushf <== NOT EXECUTED 10a3a7: fa cli <== NOT EXECUTED 10a3a8: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10a3a9: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10a3ac: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a3af: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10a3b2: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a3b5: 89 7b 30 mov %edi,0x30(%ebx) <== NOT EXECUTED information->local_table = local_table; 10a3b8: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a3bb: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED information->maximum = maximum; 10a3be: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10a3c1: 66 89 53 10 mov %dx,0x10(%ebx) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10a3c5: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10a3c7: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a3ca: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a3d0: 0f b7 43 04 movzwl 0x4(%ebx),%eax <== NOT EXECUTED 10a3d4: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10a3d7: 09 c2 or %eax,%edx <== NOT EXECUTED 10a3d9: 0f b7 45 d0 movzwl -0x30(%ebp),%eax <== NOT EXECUTED 10a3dd: 09 c2 or %eax,%edx <== NOT EXECUTED 10a3df: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10a3e2: 51 push %ecx <== NOT EXECUTED 10a3e3: 9d popf <== NOT EXECUTED if ( old_tables ) 10a3e4: 85 f6 test %esi,%esi <== NOT EXECUTED 10a3e6: 74 0c je 10a3f4 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED _Workspace_Free( old_tables ); 10a3e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3eb: 56 push %esi <== NOT EXECUTED 10a3ec: e8 57 19 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10a3f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10a3f4: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a3f8: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10a3fb: 74 32 je 10a42f <_Objects_Extend_information+0x1db> <== NOT EXECUTED information->object_blocks[ block ] = 10a3fd: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a400: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a403: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a406: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 10a409: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a40c: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a410: 50 push %eax <== NOT EXECUTED 10a411: e8 47 19 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10a416: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10a419: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10a41b: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a41e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a421: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a424: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a428: 75 26 jne 10a450 <_Objects_Extend_information+0x1fc> <== NOT EXECUTED 10a42a: e9 95 00 00 00 jmp 10a4c4 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 10a42f: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a432: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a435: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a438: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED 10a43b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a43e: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a442: 50 push %eax <== NOT EXECUTED 10a443: e8 2a 19 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a448: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 10a44b: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10a44d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10a450: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10a453: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a456: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10a459: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10a45c: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10a45f: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a462: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a465: ff 34 90 pushl (%eax,%edx,4) <== NOT EXECUTED 10a468: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 10a46b: 57 push %edi <== NOT EXECUTED 10a46c: e8 f7 31 00 00 call 10d668 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a471: 8d 4b 20 lea 0x20(%ebx),%ecx <== NOT EXECUTED 10a474: 89 4d b8 mov %ecx,-0x48(%ebp) <== NOT EXECUTED 10a477: 8b 75 c4 mov -0x3c(%ebp),%esi <== NOT EXECUTED 10a47a: eb 24 jmp 10a4a0 <_Objects_Extend_information+0x24c> <== NOT EXECUTED index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10a47c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10a47e: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10a481: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10a486: 0f b7 53 04 movzwl 0x4(%ebx),%edx <== NOT EXECUTED 10a48a: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10a48d: 09 d0 or %edx,%eax <== NOT EXECUTED 10a48f: 09 f0 or %esi,%eax <== NOT EXECUTED 10a491: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a494: 50 push %eax <== NOT EXECUTED 10a495: 50 push %eax <== NOT EXECUTED 10a496: 51 push %ecx <== NOT EXECUTED 10a497: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 10a49a: e8 81 f5 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED index++; 10a49f: 46 inc %esi <== NOT EXECUTED * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 10a4a0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a4a3: e8 9c f5 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a4a8: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a4aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4af: 75 cb jne 10a47c <_Objects_Extend_information+0x228> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10a4b1: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10a4b4: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10a4b7: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10a4ba: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10a4bd: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10a4c0: 66 01 43 2c add %ax,0x2c(%ebx) <== NOT EXECUTED } 10a4c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a4c7: 5b pop %ebx <== NOT EXECUTED 10a4c8: 5e pop %esi <== NOT EXECUTED 10a4c9: 5f pop %edi <== NOT EXECUTED 10a4ca: c9 leave <== NOT EXECUTED 10a4cb: c3 ret <== NOT EXECUTED 0010a4cc <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10a4cc: 55 push %ebp <== NOT EXECUTED 10a4cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4cf: 57 push %edi <== NOT EXECUTED 10a4d0: 56 push %esi <== NOT EXECUTED 10a4d1: 53 push %ebx <== NOT EXECUTED 10a4d2: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a4d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10a4db: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10a4de: 56 push %esi <== NOT EXECUTED 10a4df: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10a4e2: 50 push %eax <== NOT EXECUTED 10a4e3: e8 38 f5 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10a4e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4eb: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a4ef: 74 44 je 10a535 <_Objects_Free+0x69> <== NOT EXECUTED uint32_t block; block = 10a4f1: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a4f4: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a4f9: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a4fc: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a502: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]++; 10a504: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a506: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a509: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a50c: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a50f: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10a511: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10a514: 42 inc %edx <== NOT EXECUTED 10a515: 66 89 53 2c mov %dx,0x2c(%ebx) <== NOT EXECUTED /* * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { 10a519: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10a51c: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a51e: d1 e8 shr %eax <== NOT EXECUTED 10a520: 01 f8 add %edi,%eax <== NOT EXECUTED 10a522: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a524: 76 0f jbe 10a535 <_Objects_Free+0x69> <== NOT EXECUTED _Objects_Shrink_information( information ); 10a526: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10a529: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a52c: 5b pop %ebx <== NOT EXECUTED 10a52d: 5e pop %esi <== NOT EXECUTED 10a52e: 5f pop %edi <== NOT EXECUTED 10a52f: c9 leave <== NOT EXECUTED * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { _Objects_Shrink_information( information ); 10a530: e9 87 02 00 00 jmp 10a7bc <_Objects_Shrink_information> <== NOT EXECUTED } } } 10a535: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a538: 5b pop %ebx <== NOT EXECUTED 10a539: 5e pop %esi <== NOT EXECUTED 10a53a: 5f pop %edi <== NOT EXECUTED 10a53b: c9 leave <== NOT EXECUTED 10a53c: c3 ret <== NOT EXECUTED 0010a600 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10a600: 55 push %ebp <== NOT EXECUTED 10a601: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a603: 56 push %esi <== NOT EXECUTED 10a604: 53 push %ebx <== NOT EXECUTED 10a605: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10a608: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 10a60b: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a610: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10a613: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 10a616: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10a61a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a61c: 77 2a ja 10a648 <_Objects_Get+0x48> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a61e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10a623: 40 inc %eax <== NOT EXECUTED 10a624: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10a629: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10a62c: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10a62f: 85 db test %ebx,%ebx <== NOT EXECUTED 10a631: 74 08 je 10a63b <_Objects_Get+0x3b> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a633: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 10a639: eb 15 jmp 10a650 <_Objects_Get+0x50> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10a63b: e8 80 07 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10a640: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a646: eb 08 jmp 10a650 <_Objects_Get+0x50> <== NOT EXECUTED /* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR; 10a648: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a64e: 31 db xor %ebx,%ebx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a650: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a652: 5b pop %ebx <== NOT EXECUTED 10a653: 5e pop %esi <== NOT EXECUTED 10a654: c9 leave <== NOT EXECUTED 10a655: c3 ret <== NOT EXECUTED 0010a560 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10a560: 55 push %ebp <== NOT EXECUTED 10a561: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a563: 56 push %esi <== NOT EXECUTED 10a564: 53 push %ebx <== NOT EXECUTED 10a565: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a568: 8b 75 0c mov 0xc(%ebp),%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. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a56b: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10a56e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a571: 77 2f ja 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a573: eb 36 jmp 10a5ab <_Objects_Get_information+0x4b> <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10a575: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a578: 53 push %ebx <== NOT EXECUTED 10a579: e8 f2 34 00 00 call 10da70 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10a57e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a581: 85 c0 test %eax,%eax <== NOT EXECUTED 10a583: 78 1d js 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a585: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10a587: 77 19 ja 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10a589: 8b 04 9d d4 c9 11 00 mov 0x11c9d4(,%ebx,4),%eax <== NOT EXECUTED 10a590: 85 c0 test %eax,%eax <== NOT EXECUTED 10a592: 74 0e je 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10a594: 8b 04 b0 mov (%eax,%esi,4),%eax <== NOT EXECUTED if ( !info ) 10a597: 85 c0 test %eax,%eax <== NOT EXECUTED 10a599: 74 09 je 10a5a4 <_Objects_Get_information+0x44> <== NOT EXECUTED * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 10a59b: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10a5a0: 75 02 jne 10a5a4 <_Objects_Get_information+0x44> <== NOT EXECUTED 10a5a2: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10a5a4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a5a7: 5b pop %ebx <== NOT EXECUTED 10a5a8: 5e pop %esi <== NOT EXECUTED 10a5a9: c9 leave <== NOT EXECUTED 10a5aa: c3 ret <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10a5ab: 85 f6 test %esi,%esi <== NOT EXECUTED 10a5ad: 74 f3 je 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a5af: eb c4 jmp 10a575 <_Objects_Get_information+0x15> <== NOT EXECUTED 0010a540 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10a540: 55 push %ebp <== NOT EXECUTED 10a541: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a543: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a546: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10a549: 89 c2 mov %eax,%edx <== NOT EXECUTED 10a54b: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10a54e: 52 push %edx <== NOT EXECUTED 10a54f: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a552: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a555: 50 push %eax <== NOT EXECUTED 10a556: e8 05 00 00 00 call 10a560 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10a55b: c9 leave <== NOT EXECUTED 10a55c: c3 ret <== NOT EXECUTED 0010a5b4 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10a5b4: 55 push %ebp <== NOT EXECUTED 10a5b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5b7: 56 push %esi <== NOT EXECUTED 10a5b8: 53 push %ebx <== NOT EXECUTED 10a5b9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a5bc: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) index = id - information->minimum_id + 1; #else /* index = _Objects_Get_index( id ); */ index = id & 0x0000ffff; 10a5bf: 0f b7 55 0c movzwl 0xc(%ebp),%edx <== NOT EXECUTED /* This should work but doesn't always :( */ /* index = (uint16_t ) id; */ #endif _ISR_Disable( level ); 10a5c3: 9c pushf <== NOT EXECUTED 10a5c4: fa cli <== NOT EXECUTED 10a5c5: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10a5c6: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a5ca: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10a5cc: 72 21 jb 10a5ef <_Objects_Get_isr_disable+0x3b> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10a5ce: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10a5d1: 8b 14 90 mov (%eax,%edx,4),%edx <== NOT EXECUTED 10a5d4: 85 d2 test %edx,%edx <== NOT EXECUTED 10a5d6: 74 0d je 10a5e5 <_Objects_Get_isr_disable+0x31> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a5d8: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED *level_p = level; 10a5de: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5e1: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10a5e3: eb 14 jmp 10a5f9 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return the_object; } _ISR_Enable( level ); 10a5e5: 51 push %ecx <== NOT EXECUTED 10a5e6: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a5e7: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a5ed: eb 0a jmp 10a5f9 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return NULL; } _ISR_Enable( level ); 10a5ef: 51 push %ecx <== NOT EXECUTED 10a5f0: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a5f1: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a5f7: 31 d2 xor %edx,%edx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a5f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a5fb: 5b pop %ebx <== NOT EXECUTED 10a5fc: 5e pop %esi <== NOT EXECUTED 10a5fd: c9 leave <== NOT EXECUTED 10a5fe: c3 ret <== NOT EXECUTED 00112f18 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 112f18: 55 push %ebp <== NOT EXECUTED 112f19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f1b: 57 push %edi <== NOT EXECUTED 112f1c: 56 push %esi <== NOT EXECUTED 112f1d: 53 push %ebx <== NOT EXECUTED 112f1e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 112f21: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112f25: 0f 84 b3 00 00 00 je 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; if ( name == NULL ) 112f2b: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 112f2f: 0f 84 b0 00 00 00 je 112fe5 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 112f35: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 112f38: 85 db test %ebx,%ebx <== NOT EXECUTED 112f3a: 75 08 jne 112f44 <_Objects_Get_name_as_string+0x2c> <== NOT EXECUTED 112f3c: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112f41: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 112f44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f47: 53 push %ebx <== NOT EXECUTED 112f48: e8 6f ac ff ff call 10dbbc <_Objects_Get_information_id> <== NOT EXECUTED 112f4d: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 112f4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f52: 85 c0 test %eax,%eax <== NOT EXECUTED 112f54: 0f 84 84 00 00 00 je 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 112f5a: 50 push %eax <== NOT EXECUTED 112f5b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112f5e: 50 push %eax <== NOT EXECUTED 112f5f: 53 push %ebx <== NOT EXECUTED 112f60: 56 push %esi <== NOT EXECUTED 112f61: e8 16 ad ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED switch ( location ) { 112f66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f69: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112f6d: 75 6f jne 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 112f6f: 80 7e 38 00 cmpb $0x0,0x38(%esi) <== NOT EXECUTED 112f73: 74 0c je 112f81 <_Objects_Get_name_as_string+0x69> <== NOT EXECUTED s = the_object->name.name_p; 112f75: 8b 78 0c mov 0xc(%eax),%edi <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 112f78: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 112f7b: 85 ff test %edi,%edi <== NOT EXECUTED 112f7d: 75 27 jne 112fa6 <_Objects_Get_name_as_string+0x8e> <== NOT EXECUTED 112f7f: eb 53 jmp 112fd4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED case OBJECTS_LOCAL: if ( information->is_string ) { s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 112f81: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 112f84: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f86: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 112f89: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 112f8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f8e: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 112f91: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 112f94: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f96: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 112f99: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 112f9c: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 112f9f: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 112fa3: 8d 7d eb lea -0x15(%ebp),%edi <== NOT EXECUTED 112fa6: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 112fa9: 31 db xor %ebx,%ebx <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 112fab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112fae: 48 dec %eax <== NOT EXECUTED 112faf: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 112fb2: eb 14 jmp 112fc8 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 112fb4: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 112fb7: a1 34 61 12 00 mov 0x126134,%eax <== NOT EXECUTED 112fbc: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 112fc0: 75 02 jne 112fc4 <_Objects_Get_name_as_string+0xac> <== NOT EXECUTED 112fc2: b1 2a mov $0x2a,%cl <== NOT EXECUTED 112fc4: 88 0e mov %cl,(%esi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 112fc6: 43 inc %ebx <== NOT EXECUTED 112fc7: 46 inc %esi <== NOT EXECUTED 112fc8: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 112fcb: 73 07 jae 112fd4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 112fcd: 8a 0c 1f mov (%edi,%ebx,1),%cl <== NOT EXECUTED 112fd0: 84 c9 test %cl,%cl <== NOT EXECUTED 112fd2: 75 e0 jne 112fb4 <_Objects_Get_name_as_string+0x9c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 112fd4: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 112fd7: e8 60 b4 ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 112fdc: eb 07 jmp 112fe5 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return name; 112fde: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED } return NULL; /* unreachable path */ } 112fe5: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112fe8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112feb: 5b pop %ebx <== NOT EXECUTED 112fec: 5e pop %esi <== NOT EXECUTED 112fed: 5f pop %edi <== NOT EXECUTED 112fee: c9 leave <== NOT EXECUTED 112fef: c3 ret <== NOT EXECUTED 001150e4 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 1150e4: 55 push %ebp <== NOT EXECUTED 1150e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1150e7: 57 push %edi <== NOT EXECUTED 1150e8: 56 push %esi <== NOT EXECUTED 1150e9: 53 push %ebx <== NOT EXECUTED 1150ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1150ed: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1150f0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 1150f3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1150f6: 66 85 db test %bx,%bx <== NOT EXECUTED 1150f9: 75 03 jne 1150fe <_Objects_Get_next+0x1a> <== NOT EXECUTED next_id = information->minimum_id; 1150fb: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 1150fe: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 115102: 73 13 jae 115117 <_Objects_Get_next+0x33> <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 115104: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 11510a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11510d: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 115113: 31 c0 xor %eax,%eax <== NOT EXECUTED 115115: eb 17 jmp 11512e <_Objects_Get_next+0x4a> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 115117: 50 push %eax <== NOT EXECUTED 115118: 56 push %esi <== NOT EXECUTED 115119: 53 push %ebx <== NOT EXECUTED 11511a: 57 push %edi <== NOT EXECUTED 11511b: e8 5c 8b ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED next_id++; 115120: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 115121: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115124: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 115127: 75 d5 jne 1150fe <_Objects_Get_next+0x1a> <== NOT EXECUTED *next_id_p = next_id; 115129: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11512c: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 11512e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115131: 5b pop %ebx <== NOT EXECUTED 115132: 5e pop %esi <== NOT EXECUTED 115133: 5f pop %edi <== NOT EXECUTED 115134: c9 leave <== NOT EXECUTED 115135: c3 ret <== NOT EXECUTED 00114ef0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 114ef0: 55 push %ebp <== NOT EXECUTED 114ef1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ef3: 53 push %ebx <== NOT EXECUTED 114ef4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 114ef7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 114efa: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 114eff: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 114f02: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 114f05: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 114f09: 39 d0 cmp %edx,%eax <== NOT EXECUTED 114f0b: 72 12 jb 114f1f <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 114f0d: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 114f10: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 114f13: 85 c0 test %eax,%eax <== NOT EXECUTED 114f15: 74 08 je 114f1f <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED *location = OBJECTS_LOCAL; 114f17: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 114f1d: eb 08 jmp 114f27 <_Objects_Get_no_protection+0x37> <== NOT EXECUTED /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 114f1f: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 114f25: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 114f27: 5b pop %ebx <== NOT EXECUTED 114f28: c9 leave <== NOT EXECUTED 114f29: c3 ret <== NOT EXECUTED 0010a7b4 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10a7b4: 55 push %ebp <== NOT EXECUTED 10a7b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10a7b7: c9 leave <== NOT EXECUTED 10a7b8: c3 ret <== NOT EXECUTED 0010b5a0 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10b5a0: 55 push %ebp <== NOT EXECUTED 10b5a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5a3: 53 push %ebx <== NOT EXECUTED 10b5a4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b5a7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10b5aa: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b5af: 85 db test %ebx,%ebx <== NOT EXECUTED 10b5b1: 74 59 je 10b60c <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b5b3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b5b6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b5b8: 75 08 jne 10b5c2 <_Objects_Id_to_name+0x22> <== NOT EXECUTED 10b5ba: a1 8c f5 11 00 mov 0x11f58c,%eax <== NOT EXECUTED 10b5bf: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10b5c2: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b5c4: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10b5c7: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10b5ca: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10b5cd: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b5d0: 77 35 ja 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 10b5d2: eb 3d jmp 10b611 <_Objects_Id_to_name+0x71> <== NOT EXECUTED if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10b5d4: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b5d6: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10b5d9: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10b5dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10b5de: 74 27 je 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10b5e0: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10b5e4: 75 21 jne 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10b5e6: 50 push %eax <== NOT EXECUTED 10b5e7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b5ea: 50 push %eax <== NOT EXECUTED 10b5eb: 51 push %ecx <== NOT EXECUTED 10b5ec: 52 push %edx <== NOT EXECUTED 10b5ed: e8 56 ff ff ff call 10b548 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10b5f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5f5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5f7: 74 0e je 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10b5f9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10b5fc: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b5fe: e8 85 07 00 00 call 10bd88 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b603: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b605: eb 05 jmp 10b60c <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10b607: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10b60c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b60f: c9 leave <== NOT EXECUTED 10b610: c3 ret <== NOT EXECUTED the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10b611: 8b 14 95 a0 f4 11 00 mov 0x11f4a0(,%edx,4),%edx <== NOT EXECUTED 10b618: 85 d2 test %edx,%edx <== NOT EXECUTED 10b61a: 75 b8 jne 10b5d4 <_Objects_Id_to_name+0x34> <== NOT EXECUTED 10b61c: eb e9 jmp 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 0010a658 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10a658: 55 push %ebp <== NOT EXECUTED 10a659: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a65b: 57 push %edi <== NOT EXECUTED 10a65c: 56 push %esi <== NOT EXECUTED 10a65d: 53 push %ebx <== NOT EXECUTED 10a65e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a661: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a664: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a667: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10a66a: 0f b7 4d 18 movzwl 0x18(%ebp),%ecx <== NOT EXECUTED uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10a66e: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10a670: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10a674: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10a677: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10a67a: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10a681: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10a688: 66 c7 47 2c 00 00 movw $0x0,0x2c(%edi) <== NOT EXECUTED /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10a68e: 8b 04 95 d4 c9 11 00 mov 0x11c9d4(,%edx,4),%eax <== NOT EXECUTED 10a695: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10a698: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10a69b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a69e: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10a6a1: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10a6a4: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10a6a7: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10a6ad: 89 4f 14 mov %ecx,0x14(%edi) <== NOT EXECUTED /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10a6b0: c7 47 1c b8 c7 11 00 movl $0x11c7b8,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10a6b7: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a6ba: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a6c0: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10a6c3: 09 da or %ebx,%edx <== NOT EXECUTED 10a6c5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6c7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6c9: 0f 95 c0 setne %al <== NOT EXECUTED 10a6cc: 09 c2 or %eax,%edx <== NOT EXECUTED 10a6ce: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10a6d1: 89 f0 mov %esi,%eax <== NOT EXECUTED 10a6d3: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10a6d9: 74 06 je 10a6e1 <_Objects_Initialize_information+0x89> <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10a6db: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10a6de: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10a6e1: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10a6e5: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10a6e8: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10a6eb: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10a6f2: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10a6f5: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10a6f8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6fa: 74 12 je 10a70e <_Objects_Initialize_information+0xb6> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10a6fc: 66 c7 47 10 00 00 movw $0x0,0x10(%edi) <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10a702: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a705: 5b pop %ebx <== NOT EXECUTED 10a706: 5e pop %esi <== NOT EXECUTED 10a707: 5f pop %edi <== NOT EXECUTED 10a708: c9 leave <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10a709: e9 46 fb ff ff jmp 10a254 <_Objects_Extend_information> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a70e: 5b pop %ebx <== NOT EXECUTED 10a70f: 5e pop %esi <== NOT EXECUTED 10a710: 5f pop %edi <== NOT EXECUTED 10a711: c9 leave <== NOT EXECUTED 10a712: c3 ret <== NOT EXECUTED 0010a748 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10a748: 55 push %ebp <== NOT EXECUTED 10a749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a74b: 57 push %edi <== NOT EXECUTED 10a74c: 56 push %esi <== NOT EXECUTED 10a74d: 53 push %ebx <== NOT EXECUTED 10a74e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a751: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a754: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10a757: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10a75a: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10a75f: 85 f6 test %esi,%esi <== NOT EXECUTED 10a761: 74 49 je 10a7ac <_Objects_Name_to_id_u32+0x64> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10a763: 85 db test %ebx,%ebx <== NOT EXECUTED 10a765: 74 40 je 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10a767: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 10a76a: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10a76d: 74 38 je 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a76f: 85 d2 test %edx,%edx <== NOT EXECUTED 10a771: 74 28 je 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a773: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx <== NOT EXECUTED 10a779: 74 20 je 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a77b: 4a dec %edx <== NOT EXECUTED 10a77c: 75 29 jne 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a77e: eb 1b jmp 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10a780: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED 10a783: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10a786: 85 c0 test %eax,%eax <== NOT EXECUTED 10a788: 74 0e je 10a798 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10a78a: 3b 58 0c cmp 0xc(%eax),%ebx <== NOT EXECUTED 10a78d: 75 09 jne 10a798 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED *id = the_object->id; 10a78f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a792: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10a794: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a796: eb 14 jmp 10a7ac <_Objects_Name_to_id_u32+0x64> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10a798: 42 inc %edx <== NOT EXECUTED 10a799: eb 08 jmp 10a7a3 <_Objects_Name_to_id_u32+0x5b> <== NOT EXECUTED 10a79b: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a7a0: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED 10a7a3: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10a7a5: 76 d9 jbe 10a780 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10a7a7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10a7ac: 5b pop %ebx <== NOT EXECUTED 10a7ad: 5e pop %esi <== NOT EXECUTED 10a7ae: 5f pop %edi <== NOT EXECUTED 10a7af: c9 leave <== NOT EXECUTED 10a7b0: c3 ret <== NOT EXECUTED 0010a714 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10a714: 55 push %ebp <== NOT EXECUTED 10a715: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a717: 53 push %ebx <== NOT EXECUTED 10a718: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a71b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * If this is a string format name, then free the memory. */ if ( information->is_string && the_object->name.name_p ) 10a71e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a721: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10a725: 74 13 je 10a73a <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10a727: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a72a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a72c: 74 0c je 10a73a <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10a72e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a731: 50 push %eax <== NOT EXECUTED 10a732: e8 11 16 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10a737: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10a73a: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10a741: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a744: c9 leave <== NOT EXECUTED 10a745: c3 ret <== NOT EXECUTED 0010bf8c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10bf8c: 55 push %ebp <== NOT EXECUTED 10bf8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf8f: 57 push %edi <== NOT EXECUTED 10bf90: 56 push %esi <== NOT EXECUTED 10bf91: 53 push %ebx <== NOT EXECUTED 10bf92: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bf95: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bf98: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10bf9b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10bf9f: 50 push %eax <== NOT EXECUTED 10bfa0: 57 push %edi <== NOT EXECUTED 10bfa1: e8 de 56 00 00 call 111684 <== NOT EXECUTED 10bfa6: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10bfa9: 89 c6 mov %eax,%esi <== NOT EXECUTED 10bfab: 46 inc %esi <== NOT EXECUTED if ( information->is_string ) { 10bfac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfaf: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10bfb3: 74 56 je 10c00b <_Objects_Set_name+0x7f> <== NOT EXECUTED char *d; d = _Workspace_Allocate( length ); 10bfb5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfb8: 56 push %esi <== NOT EXECUTED 10bfb9: e8 4f 16 00 00 call 10d60d <_Workspace_Allocate> <== NOT EXECUTED 10bfbe: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10bfc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfc3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bfc5: 85 db test %ebx,%ebx <== NOT EXECUTED 10bfc7: 0f 84 81 00 00 00 je 10c04e <_Objects_Set_name+0xc2> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10bfcd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bfd0: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10bfd3: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfd5: 74 16 je 10bfed <_Objects_Set_name+0x61> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bfd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfda: 50 push %eax <== NOT EXECUTED 10bfdb: e8 18 16 00 00 call 10d5f8 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10bfe0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfe3: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10bfea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10bfed: 50 push %eax <== NOT EXECUTED 10bfee: 56 push %esi <== NOT EXECUTED 10bfef: 57 push %edi <== NOT EXECUTED 10bff0: 53 push %ebx <== NOT EXECUTED 10bff1: e8 06 56 00 00 call 1115fc <== NOT EXECUTED d[ length ] = '\0'; 10bff6: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10bff9: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1) <== NOT EXECUTED the_object->name.name_p = d; 10bffe: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c001: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED 10c004: b0 01 mov $0x1,%al <== NOT EXECUTED 10c006: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c009: eb 43 jmp 10c04e <_Objects_Set_name+0xc2> <== NOT EXECUTED } else { the_object->name.name_u32 = _Objects_Build_name( 10c00b: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10c010: 85 f6 test %esi,%esi <== NOT EXECUTED 10c012: 74 4e je 10c062 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10c014: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED 10c017: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10c01a: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10c01d: 74 43 je 10c062 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10c01f: 0f be 5f 01 movsbl 0x1(%edi),%ebx <== NOT EXECUTED 10c023: c1 e3 10 shl $0x10,%ebx <== NOT EXECUTED 10c026: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10c029: 76 2b jbe 10c056 <_Objects_Set_name+0xca> <== NOT EXECUTED 10c02b: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10c02f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10c032: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10c037: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10c03a: 76 04 jbe 10c040 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10c03c: 0f be 4f 03 movsbl 0x3(%edi),%ecx <== NOT EXECUTED 10c040: 09 d8 or %ebx,%eax <== NOT EXECUTED 10c042: 09 d0 or %edx,%eax <== NOT EXECUTED 10c044: 09 c8 or %ecx,%eax <== NOT EXECUTED 10c046: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c049: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10c04c: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10c04e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c051: 5b pop %ebx <== NOT EXECUTED 10c052: 5e pop %esi <== NOT EXECUTED 10c053: 5f pop %edi <== NOT EXECUTED 10c054: c9 leave <== NOT EXECUTED 10c055: c3 ret <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10c056: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10c05b: ba 00 20 00 00 mov $0x2000,%edx <== NOT EXECUTED 10c060: eb de jmp 10c040 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10c062: bb 00 00 20 00 mov $0x200000,%ebx <== NOT EXECUTED 10c067: eb ed jmp 10c056 <_Objects_Set_name+0xca> <== NOT EXECUTED 0010a7bc <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10a7bc: 55 push %ebp <== NOT EXECUTED 10a7bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7bf: 57 push %edi <== NOT EXECUTED 10a7c0: 56 push %esi <== NOT EXECUTED 10a7c1: 53 push %ebx <== NOT EXECUTED 10a7c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a7c5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a7c8: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a7cb: 0f b7 f8 movzwl %ax,%edi <== NOT EXECUTED /* * Search the list to find block or chunnk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; 10a7ce: 8b 4e 14 mov 0x14(%esi),%ecx <== NOT EXECUTED 10a7d1: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a7d5: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a7d7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a7d9: f7 f1 div %ecx <== NOT EXECUTED 10a7db: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a7dd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a7df: eb 7c jmp 10a85d <_Objects_Shrink_information+0xa1> <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10a7e1: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax <== NOT EXECUTED 10a7e8: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10a7eb: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a7ee: 39 0c 90 cmp %ecx,(%eax,%edx,4) <== NOT EXECUTED 10a7f1: 75 67 jne 10a85a <_Objects_Shrink_information+0x9e> <== 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; 10a7f3: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 10a7f6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10a7f9: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10a7fc: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 10a7fe: 72 1b jb 10a81b <_Objects_Shrink_information+0x5f> <== NOT EXECUTED 10a800: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a802: 03 46 14 add 0x14(%esi),%eax <== NOT EXECUTED 10a805: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a807: 73 12 jae 10a81b <_Objects_Shrink_information+0x5f> <== NOT EXECUTED * @param[in] start_address is the starting address of the user block * to free * @return TRUE if successfully freed, FALSE otherwise */ bool _Protected_heap_Free( Heap_Control *the_heap, 10a809: 8b 1a mov (%edx),%ebx <== NOT EXECUTED if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 10a80b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a80e: 52 push %edx <== NOT EXECUTED 10a80f: e8 3c 2e 00 00 call 10d650 <_Chain_Extract> <== NOT EXECUTED 10a814: 89 da mov %ebx,%edx <== NOT EXECUTED 10a816: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a819: eb 02 jmp 10a81d <_Objects_Shrink_information+0x61> <== NOT EXECUTED } else { the_object = (Objects_Control *) the_object->Node.next; 10a81b: 8b 12 mov (%edx),%edx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10a81d: 85 d2 test %edx,%edx <== NOT EXECUTED 10a81f: 74 05 je 10a826 <_Objects_Shrink_information+0x6a> <== NOT EXECUTED 10a821: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10a824: 75 d0 jne 10a7f6 <_Objects_Shrink_information+0x3a> <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10a826: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a829: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a82c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a82f: ff 34 10 pushl (%eax,%edx,1) <== NOT EXECUTED 10a832: e8 11 15 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10a837: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a83a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a83d: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10a844: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a847: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10a84e: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10a851: 66 29 46 2c sub %ax,0x2c(%esi) <== NOT EXECUTED 10a855: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a858: eb 07 jmp 10a861 <_Objects_Shrink_information+0xa5> <== NOT EXECUTED return; } index_base += information->allocation_size; 10a85a: 01 cf add %ecx,%edi <== NOT EXECUTED */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10a85c: 42 inc %edx <== NOT EXECUTED 10a85d: 39 da cmp %ebx,%edx <== NOT EXECUTED 10a85f: 72 80 jb 10a7e1 <_Objects_Shrink_information+0x25> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10a861: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a864: 5b pop %ebx <== NOT EXECUTED 10a865: 5e pop %esi <== NOT EXECUTED 10a866: 5f pop %edi <== NOT EXECUTED 10a867: c9 leave <== NOT EXECUTED 10a868: c3 ret <== NOT EXECUTED 0010d2d0 <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10d2d0: 55 push %ebp <== NOT EXECUTED 10d2d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2d6: 6a 04 push $0x4 <== NOT EXECUTED 10d2d8: 6a 00 push $0x0 <== NOT EXECUTED 10d2da: 6a 30 push $0x30 <== NOT EXECUTED 10d2dc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d2df: 6a 05 push $0x5 <== NOT EXECUTED 10d2e1: 6a 02 push $0x2 <== NOT EXECUTED 10d2e3: 68 b4 cd 11 00 push $0x11cdb4 <== NOT EXECUTED 10d2e8: e8 6b d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d2ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10d2f0: c9 leave <== NOT EXECUTED 10d2f1: c3 ret <== NOT EXECUTED 0010a86c <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10a86c: 55 push %ebp <== NOT EXECUTED 10a86d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a86f: 53 push %ebx <== NOT EXECUTED 10a870: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10a873: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a879: e8 2e f1 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10a87e: 5a pop %edx <== NOT EXECUTED 10a87f: 59 pop %ecx <== NOT EXECUTED 10a880: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a883: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a886: e8 11 30 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED 10a88b: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a88d: 58 pop %eax <== NOT EXECUTED 10a88e: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a894: e8 5b f1 ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10a899: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a89b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a89e: c9 leave <== NOT EXECUTED 10a89f: c3 ret <== NOT EXECUTED 0010c570 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10c570: 55 push %ebp <== NOT EXECUTED 10c571: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c573: 53 push %ebx <== NOT EXECUTED 10c574: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10c577: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c57d: e8 9a eb ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10c582: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c585: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c588: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c58b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c58e: e8 99 f1 ff ff call 10b72c <_Heap_Allocate_aligned> <== NOT EXECUTED 10c593: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c595: 58 pop %eax <== NOT EXECUTED 10c596: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c59c: e8 c3 eb ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10c5a1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c5a3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c5a6: c9 leave <== NOT EXECUTED 10c5a7: c3 ret <== NOT EXECUTED 0010c5dc <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10c5dc: 55 push %ebp <== NOT EXECUTED 10c5dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5df: 53 push %ebx <== NOT EXECUTED 10c5e0: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10c5e3: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c5e9: e8 2e eb ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10c5ee: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c5f1: 50 push %eax <== NOT EXECUTED 10c5f2: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c5f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c5f8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c5fb: e8 74 32 00 00 call 10f874 <_Heap_Extend> <== NOT EXECUTED 10c600: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c602: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10c605: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c60b: e8 54 eb ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED 10c610: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c613: 85 db test %ebx,%ebx <== NOT EXECUTED 10c615: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10c618: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c61b: c9 leave <== NOT EXECUTED 10c61c: c3 ret <== NOT EXECUTED 0010a8a0 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10a8a0: 55 push %ebp <== NOT EXECUTED 10a8a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8a3: 53 push %ebx <== NOT EXECUTED 10a8a4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10a8a7: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a8ad: e8 fa f0 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10a8b2: 5a pop %edx <== NOT EXECUTED 10a8b3: 59 pop %ecx <== NOT EXECUTED 10a8b4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a8b7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a8ba: e8 49 30 00 00 call 10d908 <_Heap_Free> <== NOT EXECUTED 10a8bf: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a8c1: 58 pop %eax <== NOT EXECUTED 10a8c2: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a8c8: e8 27 f1 ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10a8cd: 88 d8 mov %bl,%al <== NOT EXECUTED 10a8cf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8d2: c9 leave <== NOT EXECUTED 10a8d3: c3 ret <== NOT EXECUTED 00114f64 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 114f64: 55 push %ebp <== NOT EXECUTED 114f65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114f67: 53 push %ebx <== NOT EXECUTED 114f68: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 114f6b: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114f71: e8 36 4a ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 114f76: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 114f79: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114f7c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114f7f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114f82: e8 4d 02 00 00 call 1151d4 <_Heap_Size_of_user_area> <== NOT EXECUTED 114f87: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 114f89: 58 pop %eax <== NOT EXECUTED 114f8a: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114f90: e8 5f 4a ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 114f95: 88 d8 mov %bl,%al <== NOT EXECUTED 114f97: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114f9a: c9 leave <== NOT EXECUTED 114f9b: c3 ret <== NOT EXECUTED 0010f3dc <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 10f3dc: 55 push %ebp <== NOT EXECUTED 10f3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f3df: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 10f3e2: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 10f3e8: e8 d3 ec ff ff call 10e0c0 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 10f3ed: 5a pop %edx <== NOT EXECUTED 10f3ee: 59 pop %ecx <== NOT EXECUTED 10f3ef: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f3f2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f3f5: e8 6a 27 01 00 call 121b64 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10f3fa: 58 pop %eax <== NOT EXECUTED 10f3fb: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 10f401: e8 02 ed ff ff call 10e108 <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 10f406: b0 01 mov $0x1,%al <== NOT EXECUTED 10f408: c9 leave <== NOT EXECUTED 10f409: c3 ret <== NOT EXECUTED 00121e34 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 121e34: 55 push %ebp <== NOT EXECUTED 121e35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e37: 56 push %esi <== NOT EXECUTED 121e38: 53 push %ebx <== NOT EXECUTED 121e39: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 121e3c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 121e3f: 85 f6 test %esi,%esi <== NOT EXECUTED 121e41: 74 33 je 121e76 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; if ( !the_info ) 121e43: 85 db test %ebx,%ebx <== NOT EXECUTED 121e45: 74 2f je 121e76 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 121e47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121e4a: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 121e50: e8 6b c2 fe ff call 10e0c0 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 121e55: 5a pop %edx <== NOT EXECUTED 121e56: 59 pop %ecx <== NOT EXECUTED 121e57: 53 push %ebx <== NOT EXECUTED 121e58: 56 push %esi <== NOT EXECUTED 121e59: e8 8a 78 00 00 call 1296e8 <_Heap_Get_information> <== NOT EXECUTED 121e5e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 121e60: 58 pop %eax <== NOT EXECUTED 121e61: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 121e67: e8 9c c2 fe ff call 10e108 <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 121e6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121e6f: 85 db test %ebx,%ebx <== NOT EXECUTED 121e71: 0f 94 c0 sete %al <== NOT EXECUTED 121e74: eb 02 jmp 121e78 <_Protected_heap_Get_information+0x44> <== NOT EXECUTED 121e76: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 121e78: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121e7b: 5b pop %ebx <== NOT EXECUTED 121e7c: 5e pop %esi <== NOT EXECUTED 121e7d: c9 leave <== NOT EXECUTED 121e7e: c3 ret <== NOT EXECUTED 00114f9c <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 114f9c: 55 push %ebp <== NOT EXECUTED 114f9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114f9f: 53 push %ebx <== NOT EXECUTED 114fa0: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 114fa3: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114fa9: e8 fe 49 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 114fae: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 114fb1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114fb4: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114fb7: 50 push %eax <== NOT EXECUTED 114fb8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114fbb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114fbe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114fc1: e8 1e 00 00 00 call 114fe4 <_Heap_Resize_block> <== NOT EXECUTED 114fc6: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 114fc8: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 114fcb: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114fd1: e8 1e 4a ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 114fd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114fd9: 85 db test %ebx,%ebx <== NOT EXECUTED 114fdb: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 114fde: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114fe1: c9 leave <== NOT EXECUTED 114fe2: c3 ret <== NOT EXECUTED 0010c750 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10c750: 55 push %ebp <== NOT EXECUTED 10c751: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c753: 57 push %edi <== NOT EXECUTED 10c754: 56 push %esi <== NOT EXECUTED 10c755: 53 push %ebx <== NOT EXECUTED 10c756: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c759: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c75c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c75f: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 10c762: a1 2c 09 12 00 mov 0x12092c,%eax <== NOT EXECUTED 10c767: 85 c0 test %eax,%eax <== NOT EXECUTED 10c769: 75 37 jne 10c7a2 <_Protected_heap_Walk+0x52> <== NOT EXECUTED _RTEMS_Lock_allocator(); 10c76b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c76e: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c774: e8 a3 e9 ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10c779: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c77c: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c77f: 50 push %eax <== NOT EXECUTED 10c780: 56 push %esi <== NOT EXECUTED 10c781: 57 push %edi <== NOT EXECUTED 10c782: e8 a5 32 00 00 call 10fa2c <_Heap_Walk> <== NOT EXECUTED 10c787: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c789: 58 pop %eax <== NOT EXECUTED 10c78a: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c790: e8 cf e9 ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED 10c795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10c798: 88 d8 mov %bl,%al <== NOT EXECUTED 10c79a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c79d: 5b pop %ebx <== NOT EXECUTED 10c79e: 5e pop %esi <== NOT EXECUTED 10c79f: 5f pop %edi <== NOT EXECUTED 10c7a0: c9 leave <== NOT EXECUTED 10c7a1: c3 ret <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10c7a2: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c7a5: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10c7a8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10c7ab: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10c7ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7b1: 5b pop %ebx <== NOT EXECUTED 10c7b2: 5e pop %esi <== NOT EXECUTED 10c7b3: 5f pop %edi <== NOT EXECUTED 10c7b4: c9 leave <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10c7b5: e9 72 32 00 00 jmp 10fa2c <_Heap_Walk> <== NOT EXECUTED 00109810 <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 109810: 55 push %ebp <== NOT EXECUTED 109811: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109813: 53 push %ebx <== NOT EXECUTED 109814: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 109817: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10981a: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10981d: c7 05 dc c9 11 00 30 movl $0x11cc30,0x11c9dc <== NOT EXECUTED 109824: cc 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 109827: e8 74 3a 00 00 call 10d2a0 <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10982c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10982f: ff 33 pushl (%ebx) <== NOT EXECUTED 109831: e8 d9 3b 00 00 call 10d40f <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 109836: 58 pop %eax <== NOT EXECUTED 109837: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10983a: e8 05 3b 00 00 call 10d344 <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10983f: e8 5c 3b 00 00 call 10d3a0 <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 109844: e8 47 3a 00 00 call 10d290 <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 109849: 58 pop %eax <== NOT EXECUTED 10984a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10984d: e8 56 3a 00 00 call 10d2a8 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 109852: 58 pop %eax <== NOT EXECUTED 109853: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 109856: e8 21 3b 00 00 call 10d37c <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10985b: 58 pop %eax <== NOT EXECUTED 10985c: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10985f: e8 6c 3a 00 00 call 10d2d0 <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 109864: 59 pop %ecx <== NOT EXECUTED 109865: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109868: e8 af 3a 00 00 call 10d31c <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10986d: 5a pop %edx <== NOT EXECUTED 10986e: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 109871: e8 f6 39 00 00 call 10d26c <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 109876: 58 pop %eax <== NOT EXECUTED 109877: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10987a: e8 75 3a 00 00 call 10d2f4 <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10987f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109882: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 109885: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 109888: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10988b: c9 leave <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10988c: e9 b7 39 00 00 jmp 10d248 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010d590 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10d590: 55 push %ebp <== NOT EXECUTED 10d591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d593: 56 push %esi <== NOT EXECUTED 10d594: 53 push %ebx <== NOT EXECUTED 10d595: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10d598: 8b 73 10 mov 0x10(%ebx),%esi <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10d59b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d59e: 3b 05 c0 ca 11 00 cmp 0x11cac0,%eax <== NOT EXECUTED 10d5a4: 75 0c jne 10d5b2 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x22> <== NOT EXECUTED value = *tvp->ptr; 10d5a6: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10d5a9: 8b 0a mov (%edx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; 10d5ab: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10d5ae: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10d5b0: eb 03 jmp 10d5b5 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x25> <== NOT EXECUTED } else { value = tvp->tval; 10d5b2: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED } if ( dtor ) 10d5b5: 85 f6 test %esi,%esi <== NOT EXECUTED 10d5b7: 74 09 je 10d5c2 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x32> <== NOT EXECUTED (*dtor)(value); 10d5b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5bc: 51 push %ecx <== NOT EXECUTED 10d5bd: ff d6 call *%esi <== NOT EXECUTED 10d5bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10d5c2: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10d5c5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d5c8: 5b pop %ebx <== NOT EXECUTED 10d5c9: 5e pop %esi <== NOT EXECUTED 10d5ca: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10d5cb: e9 78 e7 ff ff jmp 10bd48 <_Workspace_Free> <== NOT EXECUTED 0010d4ff <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10d4ff: 55 push %ebp <== NOT EXECUTED 10d500: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d502: 53 push %ebx <== NOT EXECUTED 10d503: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d506: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 10d509: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10d50e: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10d511: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10d515: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10d517: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10d51a: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10d51d: 50 push %eax <== NOT EXECUTED 10d51e: e8 3a e8 ff ff call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10d523: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10d525: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d528: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d52a: 85 d2 test %edx,%edx <== NOT EXECUTED 10d52c: 74 5d je 10d58b <_RTEMS_tasks_Create_extension+0x8c> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10d52e: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10d534: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10d53a: 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 10d53e: 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. 10d545: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10d54c: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d553: 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 10d55a: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10d561: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10d568: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10d56b: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10d570: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10d573: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10d577: 74 10 je 10d589 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10d579: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10d57b: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10d582: 00 <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 10d583: 40 inc %eax <== NOT EXECUTED 10d584: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10d587: 75 f2 jne 10d57b <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10d589: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10d58b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d58e: c9 leave <== NOT EXECUTED 10d58f: c3 ret <== NOT EXECUTED 0010d4af <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10d4af: 55 push %ebp <== NOT EXECUTED 10d4b0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d4b2: 56 push %esi <== NOT EXECUTED 10d4b3: 53 push %ebx <== NOT EXECUTED 10d4b4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10d4b7: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10d4bd: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10d4c4: 00 00 00 <== NOT EXECUTED 10d4c7: eb 10 jmp 10d4d9 <_RTEMS_tasks_Delete_extension+0x2a> <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; 10d4c9: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10d4cb: 52 push %edx <== NOT EXECUTED 10d4cc: 52 push %edx <== NOT EXECUTED 10d4cd: 50 push %eax <== NOT EXECUTED 10d4ce: 56 push %esi <== NOT EXECUTED 10d4cf: e8 bc 00 00 00 call 10d590 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10d4d4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d4d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10d4d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4db: 75 ec jne 10d4c9 <_RTEMS_tasks_Delete_extension+0x1a> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10d4dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d4e0: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10d4e6: e8 5d e8 ff ff call 10bd48 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10d4eb: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10d4f2: 00 00 00 <== NOT EXECUTED 10d4f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d4f8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d4fb: 5b pop %ebx <== NOT EXECUTED 10d4fc: 5e pop %esi <== NOT EXECUTED 10d4fd: c9 leave <== NOT EXECUTED 10d4fe: c3 ret <== NOT EXECUTED 0010d3fd <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10d3fd: 55 push %ebp <== NOT EXECUTED 10d3fe: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10d400: 8b 0d d4 86 11 00 mov 0x1186d4,%ecx <== NOT EXECUTED 10d406: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d408: 74 03 je 10d40d <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10d40a: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10d40b: ff e1 jmp *%ecx <== NOT EXECUTED } 10d40d: c9 leave <== NOT EXECUTED 10d40e: c3 ret <== NOT EXECUTED 001094b8 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 1094b8: 55 push %ebp <== NOT EXECUTED 1094b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1094bb: 57 push %edi <== NOT EXECUTED 1094bc: 56 push %esi <== NOT EXECUTED 1094bd: 53 push %ebx <== NOT EXECUTED 1094be: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 1094c1: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 1094c6: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 1094c9: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; 1094cc: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED if ( !user_tasks || maximum == 0 ) 1094cf: 85 d2 test %edx,%edx <== NOT EXECUTED 1094d1: 74 53 je 109526 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e> <== NOT EXECUTED 1094d3: 85 ff test %edi,%edi <== NOT EXECUTED 1094d5: 74 4f je 109526 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e> <== NOT EXECUTED return; 1094d7: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1094d9: 31 f6 xor %esi,%esi <== NOT EXECUTED 1094db: eb 45 jmp 109522 <_RTEMS_tasks_Initialize_user_tasks_body+0x6a> <== NOT EXECUTED for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 1094dd: 50 push %eax <== NOT EXECUTED 1094de: 50 push %eax <== NOT EXECUTED 1094df: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1094e2: 50 push %eax <== NOT EXECUTED 1094e3: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1094e6: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 1094e9: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 1094ec: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1094ef: ff 33 pushl (%ebx) <== NOT EXECUTED 1094f1: e8 ca fd ff ff call 1092c0 <== NOT EXECUTED user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 1094f6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1094f9: 85 c0 test %eax,%eax <== NOT EXECUTED 1094fb: 75 19 jne 109516 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 1094fd: 51 push %ecx <== NOT EXECUTED 1094fe: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109501: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109504: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109507: e8 24 00 00 00 call 109530 <== NOT EXECUTED 10950c: 83 c3 1c add $0x1c,%ebx <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10950f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109512: 85 c0 test %eax,%eax <== NOT EXECUTED 109514: 74 0b je 109521 <_RTEMS_tasks_Initialize_user_tasks_body+0x69> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 109516: 52 push %edx <== NOT EXECUTED 109517: 50 push %eax <== NOT EXECUTED 109518: 6a 01 push $0x1 <== NOT EXECUTED 10951a: 6a 01 push $0x1 <== NOT EXECUTED 10951c: e8 07 0c 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 109521: 46 inc %esi <== NOT EXECUTED 109522: 39 fe cmp %edi,%esi <== NOT EXECUTED 109524: 72 b7 jb 1094dd <_RTEMS_tasks_Initialize_user_tasks_body+0x25> <== NOT EXECUTED ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 109526: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109529: 5b pop %ebx <== NOT EXECUTED 10952a: 5e pop %esi <== NOT EXECUTED 10952b: 5f pop %edi <== NOT EXECUTED 10952c: c9 leave <== NOT EXECUTED 10952d: c3 ret <== NOT EXECUTED 0010d40f <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10d40f: 55 push %ebp <== NOT EXECUTED 10d410: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d412: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d415: 6a 04 push $0x4 <== NOT EXECUTED 10d417: 6a 00 push $0x0 <== NOT EXECUTED 10d419: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10d41e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d421: 6a 01 push $0x1 <== NOT EXECUTED 10d423: 6a 02 push $0x2 <== NOT EXECUTED 10d425: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 10d42a: e8 29 d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10d42f: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10d432: 68 84 a9 11 00 push $0x11a984 <== NOT EXECUTED 10d437: e8 c0 09 00 00 call 10ddfc <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10d43c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d43f: c7 45 08 70 a9 11 00 movl $0x11a970,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10d446: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10d447: e9 ea c4 ff ff jmp 109936 <_API_extensions_Add> <== NOT EXECUTED 0010d44c <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10d44c: 55 push %ebp <== NOT EXECUTED 10d44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d44f: 57 push %edi <== NOT EXECUTED 10d450: 56 push %esi <== NOT EXECUTED 10d451: 53 push %ebx <== NOT EXECUTED 10d452: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10d455: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d458: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10d45e: 85 f6 test %esi,%esi <== NOT EXECUTED 10d460: 74 45 je 10d4a7 <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10d462: 9c pushf <== NOT EXECUTED 10d463: fa cli <== NOT EXECUTED 10d464: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10d465: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10d468: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10d46f: 50 push %eax <== NOT EXECUTED 10d470: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10d471: 85 ff test %edi,%edi <== NOT EXECUTED 10d473: 74 32 je 10d4a7 <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10d475: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10d478: 50 push %eax <== NOT EXECUTED 10d479: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10d47c: 53 push %ebx <== NOT EXECUTED 10d47d: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10d482: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10d485: e8 f6 0d 00 00 call 10e280 <== NOT EXECUTED (*asr->handler)( signal_set ); 10d48a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10d48d: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10d490: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10d493: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d496: 53 push %ebx <== NOT EXECUTED 10d497: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10d49c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d49f: e8 dc 0d 00 00 call 10e280 <== NOT EXECUTED 10d4a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d4a7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d4aa: 5b pop %ebx <== NOT EXECUTED 10d4ab: 5e pop %esi <== NOT EXECUTED 10d4ac: 5f pop %edi <== NOT EXECUTED 10d4ad: c9 leave <== NOT EXECUTED 10d4ae: c3 ret <== NOT EXECUTED 0010d3a8 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10d3a8: 55 push %ebp <== NOT EXECUTED 10d3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED RTEMS_API_Control *api; api = started->API_Extensions[ THREAD_API_RTEMS ]; api->pending_events = EVENT_SETS_NONE_PENDING; 10d3ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d3ae: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10d3b4: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10d3ba: c9 leave <== NOT EXECUTED 10d3bb: c3 ret <== NOT EXECUTED 0010d3bc <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10d3bc: 55 push %ebp <== NOT EXECUTED 10d3bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10d3bf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d3c2: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10d3c8: eb 0f jmp 10d3d9 <_RTEMS_tasks_Switch_extension+0x1d> <== NOT EXECUTED while (tvp) { tvp->tval = *tvp->ptr; 10d3ca: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3cd: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d3cf: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10d3d2: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10d3d5: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10d3d7: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10d3d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d3db: 75 ed jne 10d3ca <_RTEMS_tasks_Switch_extension+0xe> <== NOT EXECUTED tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 10d3dd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d3e0: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10d3e6: eb 0f jmp 10d3f7 <_RTEMS_tasks_Switch_extension+0x3b> <== NOT EXECUTED while (tvp) { tvp->gval = *tvp->ptr; 10d3e8: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3eb: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d3ed: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10d3f0: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10d3f3: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10d3f5: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10d3f7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d3f9: 75 ed jne 10d3e8 <_RTEMS_tasks_Switch_extension+0x2c> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10d3fb: c9 leave <== NOT EXECUTED 10d3fc: c3 ret <== NOT EXECUTED 00109dac <_Rate_monotonic_Initiate_statistics>: #endif void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 109dac: 55 push %ebp <== NOT EXECUTED 109dad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109daf: 57 push %edi <== NOT EXECUTED 109db0: 56 push %esi <== NOT EXECUTED 109db1: 53 push %ebx <== NOT EXECUTED 109db2: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 109db5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *owning_thread = the_period->owner; 109db8: 8b 5e 50 mov 0x50(%esi),%ebx <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 109dbb: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 109dbe: 57 push %edi <== NOT EXECUTED 109dbf: e8 cc 16 00 00 call 10b490 <_TOD_Get_uptime> <== NOT EXECUTED /* * Set the starting point and the CPU time used for the statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS the_period->time_at_period = uptime; 109dc4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109dc7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109dca: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 109dcd: 89 56 48 mov %edx,0x48(%esi) <== NOT EXECUTED #else the_period->time_at_period = _Watchdog_Ticks_since_boot; #endif the_period->owner_executed_at_period = owning_thread->cpu_time_used; 109dd0: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 109dd6: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 109ddc: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 109ddf: 89 56 3c mov %edx,0x3c(%esi) <== NOT EXECUTED * context switch. When this routine is invoked from * rtems_rate_monotonic_period, the owner will be the executing thread. * When this routine is invoked from _Rate_monotonic_Timeout, it will not. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS if (owning_thread == _Thread_Executing) { 109de2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109de5: 3b 1d 84 0b 12 00 cmp 0x120b84,%ebx <== NOT EXECUTED 109deb: 75 1f jne 109e0c <_Rate_monotonic_Initiate_statistics+0x60> <== NOT EXECUTED /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 109ded: 51 push %ecx <== NOT EXECUTED 109dee: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 109df1: 53 push %ebx <== NOT EXECUTED 109df2: 57 push %edi <== NOT EXECUTED 109df3: 68 8c 0b 12 00 push $0x120b8c <== NOT EXECUTED 109df8: e8 d3 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 109dfd: 58 pop %eax <== NOT EXECUTED 109dfe: 5a pop %edx <== NOT EXECUTED 109dff: 53 push %ebx <== NOT EXECUTED 109e00: 8d 46 3c lea 0x3c(%esi),%eax <== NOT EXECUTED 109e03: 50 push %eax <== NOT EXECUTED 109e04: e8 d3 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED 109e09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } #endif } 109e0c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e0f: 5b pop %ebx <== NOT EXECUTED 109e10: 5e pop %esi <== NOT EXECUTED 109e11: 5f pop %edi <== NOT EXECUTED 109e12: c9 leave <== NOT EXECUTED 109e13: c3 ret <== NOT EXECUTED 0010d2f4 <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10d2f4: 55 push %ebp <== NOT EXECUTED 10d2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2fa: 6a 04 push $0x4 <== NOT EXECUTED 10d2fc: 6a 00 push $0x0 <== NOT EXECUTED 10d2fe: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10d303: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d306: 6a 08 push $0x8 <== NOT EXECUTED 10d308: 6a 02 push $0x2 <== NOT EXECUTED 10d30a: 68 f4 cd 11 00 push $0x11cdf4 <== NOT EXECUTED 10d30f: e8 44 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d314: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d317: c9 leave <== NOT EXECUTED 10d318: c3 ret <== NOT EXECUTED 0010a2e8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10a2e8: 55 push %ebp <== NOT EXECUTED 10a2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2eb: 53 push %ebx <== NOT EXECUTED 10a2ec: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a2ef: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a2f2: 50 push %eax <== NOT EXECUTED 10a2f3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a2f6: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 10a2fb: e8 f8 19 00 00 call 10bcf8 <_Objects_Get> <== NOT EXECUTED 10a300: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10a302: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a305: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a309: 75 64 jne 10a36f <_Rate_monotonic_Timeout+0x87> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 10a30b: 8b 50 50 mov 0x50(%eax),%edx <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10a30e: f6 42 11 40 testb $0x40,0x11(%edx) <== NOT EXECUTED 10a312: 74 18 je 10a32c <_Rate_monotonic_Timeout+0x44> <== NOT EXECUTED 10a314: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10a317: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10a31a: 75 10 jne 10a32c <_Rate_monotonic_Timeout+0x44> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a31c: 50 push %eax <== NOT EXECUTED 10a31d: 50 push %eax <== NOT EXECUTED 10a31e: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10a323: 52 push %edx <== NOT EXECUTED 10a324: e8 0f 1e 00 00 call 10c138 <_Thread_Clear_state> <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10a329: 59 pop %ecx <== NOT EXECUTED 10a32a: eb 10 jmp 10a33c <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10a32c: 83 7b 38 01 cmpl $0x1,0x38(%ebx) <== NOT EXECUTED 10a330: 75 2b jne 10a35d <_Rate_monotonic_Timeout+0x75> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10a332: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10a339: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a33c: 53 push %ebx <== NOT EXECUTED 10a33d: e8 6a fa ff ff call 109dac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a342: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10a345: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a348: 58 pop %eax <== NOT EXECUTED 10a349: 5a pop %edx <== NOT EXECUTED 10a34a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a34d: 50 push %eax <== NOT EXECUTED 10a34e: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a353: e8 bc 30 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED 10a358: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a35b: eb 07 jmp 10a364 <_Rate_monotonic_Timeout+0x7c> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10a35d: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) <== NOT EXECUTED 10a364: a1 c4 0a 12 00 mov 0x120ac4,%eax <== NOT EXECUTED 10a369: 48 dec %eax <== NOT EXECUTED 10a36a: a3 c4 0a 12 00 mov %eax,0x120ac4 <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a36f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a372: c9 leave <== NOT EXECUTED 10a373: c3 ret <== NOT EXECUTED 00109e14 <_Rate_monotonic_Update_statistics>: void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 109e14: 55 push %ebp <== NOT EXECUTED 109e15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e17: 57 push %edi <== NOT EXECUTED 109e18: 56 push %esi <== NOT EXECUTED 109e19: 53 push %ebx <== NOT EXECUTED 109e1a: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED 109e1d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED struct timespec uptime; /* * Obtain the current time since boot */ _TOD_Get_uptime( &uptime ); 109e20: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 109e23: 50 push %eax <== NOT EXECUTED 109e24: e8 67 16 00 00 call 10b490 <_TOD_Get_uptime> <== NOT EXECUTED /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 109e29: ff 47 54 incl 0x54(%edi) <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 109e2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e2f: 83 7f 38 04 cmpl $0x4,0x38(%edi) <== NOT EXECUTED 109e33: 75 03 jne 109e38 <_Rate_monotonic_Update_statistics+0x24> <== NOT EXECUTED stats->missed_count++; 109e35: ff 47 58 incl 0x58(%edi) <== NOT EXECUTED /* * Grab basic information for time statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 109e38: 50 push %eax <== NOT EXECUTED 109e39: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109e3c: 50 push %eax <== NOT EXECUTED 109e3d: 8d 75 dc lea -0x24(%ebp),%esi <== NOT EXECUTED 109e40: 56 push %esi <== NOT EXECUTED 109e41: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 109e44: 50 push %eax <== NOT EXECUTED 109e45: e8 86 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { rtems_thread_cpu_usage_t ran, used; /* Grab CPU usage when the thread got switched in */ used = _Thread_Executing->cpu_time_used; 109e4a: a1 84 0b 12 00 mov 0x120b84,%eax <== NOT EXECUTED 109e4f: 8b 90 84 00 00 00 mov 0x84(%eax),%edx <== NOT EXECUTED 109e55: 8b 80 88 00 00 00 mov 0x88(%eax),%eax <== NOT EXECUTED 109e5b: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 109e5e: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED /* How much time time since last context switch */ _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 109e61: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109e64: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 109e67: 53 push %ebx <== NOT EXECUTED 109e68: 56 push %esi <== NOT EXECUTED 109e69: 68 8c 0b 12 00 push $0x120b8c <== NOT EXECUTED 109e6e: e8 5d 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED /* executed += ran */ _Timespec_Add_to( &used, &ran ); 109e73: 5e pop %esi <== NOT EXECUTED 109e74: 58 pop %eax <== NOT EXECUTED 109e75: 53 push %ebx <== NOT EXECUTED 109e76: 8d 75 cc lea -0x34(%ebp),%esi <== NOT EXECUTED 109e79: 56 push %esi <== NOT EXECUTED 109e7a: e8 5d 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED /* partial period, cpu usage info reset while executing. Throw away */ if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) 109e7f: 8d 47 3c lea 0x3c(%edi),%eax <== NOT EXECUTED 109e82: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED 109e85: 5a pop %edx <== NOT EXECUTED 109e86: 59 pop %ecx <== NOT EXECUTED 109e87: 50 push %eax <== NOT EXECUTED 109e88: 56 push %esi <== NOT EXECUTED 109e89: e8 1a 33 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109e8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e91: 84 c0 test %al,%al <== NOT EXECUTED 109e93: 0f 85 b1 00 00 00 jne 109f4a <_Rate_monotonic_Update_statistics+0x136> <== NOT EXECUTED return; /* executed = current cpu usage - value at start of period */ _Timespec_Subtract( 109e99: 50 push %eax <== NOT EXECUTED 109e9a: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 109e9d: 53 push %ebx <== NOT EXECUTED 109e9e: 56 push %esi <== NOT EXECUTED 109e9f: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 109ea2: e8 29 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED /* * Update CPU time */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Add_to( &stats->total_cpu_time, &executed ); 109ea7: 59 pop %ecx <== NOT EXECUTED 109ea8: 5e pop %esi <== NOT EXECUTED 109ea9: 53 push %ebx <== NOT EXECUTED 109eaa: 8d 47 6c lea 0x6c(%edi),%eax <== NOT EXECUTED 109ead: 50 push %eax <== NOT EXECUTED 109eae: e8 29 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) ) 109eb3: 58 pop %eax <== NOT EXECUTED 109eb4: 5a pop %edx <== NOT EXECUTED 109eb5: 8d 47 5c lea 0x5c(%edi),%eax <== NOT EXECUTED 109eb8: 50 push %eax <== NOT EXECUTED 109eb9: 53 push %ebx <== NOT EXECUTED 109eba: e8 e9 32 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109ebf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ec2: 84 c0 test %al,%al <== NOT EXECUTED 109ec4: 74 0c je 109ed2 <_Rate_monotonic_Update_statistics+0xbe> <== NOT EXECUTED stats->min_cpu_time = executed; 109ec6: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109ec9: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109ecc: 89 47 5c mov %eax,0x5c(%edi) <== NOT EXECUTED 109ecf: 89 57 60 mov %edx,0x60(%edi) <== NOT EXECUTED if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) ) 109ed2: 50 push %eax <== NOT EXECUTED 109ed3: 50 push %eax <== NOT EXECUTED 109ed4: 8d 47 64 lea 0x64(%edi),%eax <== NOT EXECUTED 109ed7: 50 push %eax <== NOT EXECUTED 109ed8: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 109edb: 50 push %eax <== NOT EXECUTED 109edc: e8 9f 32 00 00 call 10d180 <_Timespec_Greater_than> <== NOT EXECUTED 109ee1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ee4: 84 c0 test %al,%al <== NOT EXECUTED 109ee6: 74 0c je 109ef4 <_Rate_monotonic_Update_statistics+0xe0> <== NOT EXECUTED stats->max_cpu_time = executed; 109ee8: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109eeb: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109eee: 89 47 64 mov %eax,0x64(%edi) <== NOT EXECUTED 109ef1: 89 57 68 mov %edx,0x68(%edi) <== NOT EXECUTED stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #else _Timespec_Add_to( &stats->total_wall_time, &since_last_period ); 109ef4: 50 push %eax <== NOT EXECUTED 109ef5: 50 push %eax <== NOT EXECUTED 109ef6: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 109ef9: 53 push %ebx <== NOT EXECUTED 109efa: 8d 87 84 00 00 00 lea 0x84(%edi),%eax <== NOT EXECUTED 109f00: 50 push %eax <== NOT EXECUTED 109f01: e8 d6 31 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) ) 109f06: 5e pop %esi <== NOT EXECUTED 109f07: 58 pop %eax <== NOT EXECUTED 109f08: 8d 47 74 lea 0x74(%edi),%eax <== NOT EXECUTED 109f0b: 50 push %eax <== NOT EXECUTED 109f0c: 53 push %ebx <== NOT EXECUTED 109f0d: e8 96 32 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109f12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f15: 84 c0 test %al,%al <== NOT EXECUTED 109f17: 74 0c je 109f25 <_Rate_monotonic_Update_statistics+0x111> <== NOT EXECUTED stats->min_wall_time = since_last_period; 109f19: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 109f1c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109f1f: 89 47 74 mov %eax,0x74(%edi) <== NOT EXECUTED 109f22: 89 57 78 mov %edx,0x78(%edi) <== NOT EXECUTED if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) 109f25: 53 push %ebx <== NOT EXECUTED 109f26: 53 push %ebx <== NOT EXECUTED 109f27: 8d 47 7c lea 0x7c(%edi),%eax <== NOT EXECUTED 109f2a: 50 push %eax <== NOT EXECUTED 109f2b: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109f2e: 50 push %eax <== NOT EXECUTED 109f2f: e8 4c 32 00 00 call 10d180 <_Timespec_Greater_than> <== NOT EXECUTED 109f34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f37: 84 c0 test %al,%al <== NOT EXECUTED 109f39: 74 0f je 109f4a <_Rate_monotonic_Update_statistics+0x136> <== NOT EXECUTED stats->max_wall_time = since_last_period; 109f3b: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 109f3e: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109f41: 89 47 7c mov %eax,0x7c(%edi) <== NOT EXECUTED 109f44: 89 97 80 00 00 00 mov %edx,0x80(%edi) <== NOT EXECUTED #endif } 109f4a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f4d: 5b pop %ebx <== NOT EXECUTED 109f4e: 5e pop %esi <== NOT EXECUTED 109f4f: 5f pop %edi <== NOT EXECUTED 109f50: c9 leave <== NOT EXECUTED 109f51: c3 ret <== NOT EXECUTED 0010d31c <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10d31c: 55 push %ebp <== NOT EXECUTED 10d31d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d31f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d322: 6a 04 push $0x4 <== NOT EXECUTED 10d324: 6a 00 push $0x0 <== NOT EXECUTED 10d326: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10d32b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d32e: 6a 06 push $0x6 <== NOT EXECUTED 10d330: 6a 02 push $0x2 <== NOT EXECUTED 10d332: 68 34 ce 11 00 push $0x11ce34 <== NOT EXECUTED 10d337: e8 1c d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d33c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10d33f: c9 leave <== NOT EXECUTED 10d340: c3 ret <== NOT EXECUTED 00118080 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 118080: 55 push %ebp <== NOT EXECUTED 118081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118083: 57 push %edi <== NOT EXECUTED 118084: 56 push %esi <== NOT EXECUTED 118085: 53 push %ebx <== NOT EXECUTED 118086: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 118089: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11808c: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 118091: 40 inc %eax <== NOT EXECUTED 118092: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 118097: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 11809d: e8 ea b8 ff ff call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 1180a2: 8d 7e 10 lea 0x10(%esi),%edi <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 1180a5: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 1180a8: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1180ab: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 1180ae: e8 dd 06 00 00 call 118790 <_Thread_queue_First> <== NOT EXECUTED 1180b3: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 1180b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1180b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1180ba: 74 30 je 1180ec <_Region_Process_queue+0x6c> <== NOT EXECUTED 1180bc: 52 push %edx <== NOT EXECUTED 1180bd: 52 push %edx <== NOT EXECUTED 1180be: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 1180c1: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1180c4: e8 0b c2 ff ff call 1142d4 <_Heap_Allocate> <== NOT EXECUTED 1180c9: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 1180cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1180ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1180d0: 74 1a je 1180ec <_Region_Process_queue+0x6c> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 1180d2: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1180d5: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 1180d7: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 1180da: 50 push %eax <== NOT EXECUTED 1180db: 50 push %eax <== NOT EXECUTED 1180dc: 53 push %ebx <== NOT EXECUTED 1180dd: 57 push %edi <== NOT EXECUTED 1180de: e8 bd 05 00 00 call 1186a0 <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 1180e3: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 1180ea: eb bf jmp 1180ab <_Region_Process_queue+0x2b> <== NOT EXECUTED } _Thread_Enable_dispatch(); } 1180ec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1180ef: 5b pop %ebx <== NOT EXECUTED 1180f0: 5e pop %esi <== NOT EXECUTED 1180f1: 5f pop %edi <== NOT EXECUTED 1180f2: c9 leave <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); the_thread->Wait.return_code = RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1180f3: e9 f4 d5 ff ff jmp 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 0010d37c <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10d37c: 55 push %ebp <== NOT EXECUTED 10d37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d37f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d382: 6a 04 push $0x4 <== NOT EXECUTED 10d384: 6a 00 push $0x0 <== NOT EXECUTED 10d386: 6a 78 push $0x78 <== NOT EXECUTED 10d388: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d38b: 6a 03 push $0x3 <== NOT EXECUTED 10d38d: 6a 02 push $0x2 <== NOT EXECUTED 10d38f: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 10d394: e8 bf d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d399: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10d39c: c9 leave <== NOT EXECUTED 10d39d: c3 ret <== NOT EXECUTED 001092a0 <_Semaphore_Translate_core_mutex_return_code>: }; rtems_status_code _Semaphore_Translate_core_mutex_return_code ( uint32_t status ) { 1092a0: 55 push %ebp <== NOT EXECUTED 1092a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1092a6: 8b 04 85 b8 67 11 00 mov 0x1167b8(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_MUTEX_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_mutex_return_code_[status]; } 1092ad: c9 leave <== NOT EXECUTED 1092ae: c3 ret <== NOT EXECUTED 001092af <_Semaphore_Translate_core_semaphore_return_code>: }; rtems_status_code _Semaphore_Translate_core_semaphore_return_code ( uint32_t status ) { 1092af: 55 push %ebp <== NOT EXECUTED 1092b0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092b2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1092b5: 8b 04 85 d4 67 11 00 mov 0x1167d4(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_SEMAPHORE_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_semaphore_return_code_[status]; } 1092bc: c9 leave <== NOT EXECUTED 1092bd: c3 ret <== NOT EXECUTED 0010d3a0 <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10d3a0: 55 push %ebp <== NOT EXECUTED 10d3a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10d3a3: c9 leave <== NOT EXECUTED 10d3a4: c3 ret <== NOT EXECUTED 00109e70 <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 109e70: 55 push %ebp <== NOT EXECUTED 109e71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e73: 56 push %esi <== NOT EXECUTED 109e74: 53 push %ebx <== NOT EXECUTED 109e75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109e78: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 109e7b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 109e82: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 109e89: 9c pushf <== NOT EXECUTED 109e8a: fa cli <== NOT EXECUTED 109e8b: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 109e8c: a1 90 ca 11 00 mov 0x11ca90,%eax <== NOT EXECUTED 109e91: 8b 15 94 ca 11 00 mov 0x11ca94,%edx <== NOT EXECUTED 109e97: 89 06 mov %eax,(%esi) <== NOT EXECUTED 109e99: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 109e9c: a1 a4 cb 11 00 mov 0x11cba4,%eax <== NOT EXECUTED 109ea1: 85 c0 test %eax,%eax <== NOT EXECUTED 109ea3: 74 05 je 109eaa <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 109ea5: ff d0 call *%eax <== NOT EXECUTED 109ea7: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 109eaa: 53 push %ebx <== NOT EXECUTED 109eab: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 109eac: 50 push %eax <== NOT EXECUTED 109ead: 50 push %eax <== NOT EXECUTED 109eae: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109eb1: 50 push %eax <== NOT EXECUTED 109eb2: 56 push %esi <== NOT EXECUTED 109eb3: e8 30 1a 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 109eb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109ebb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109ebe: 5b pop %ebx <== NOT EXECUTED 109ebf: 5e pop %esi <== NOT EXECUTED 109ec0: c9 leave <== NOT EXECUTED 109ec1: c3 ret <== NOT EXECUTED 0010d848 <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10d848: 55 push %ebp <== NOT EXECUTED 10d849: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d84b: 56 push %esi <== NOT EXECUTED 10d84c: 53 push %ebx <== NOT EXECUTED 10d84d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d850: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10d853: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10d85a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10d861: 9c pushf <== NOT EXECUTED 10d862: fa cli <== NOT EXECUTED 10d863: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10d864: a1 7c ca 11 00 mov 0x11ca7c,%eax <== NOT EXECUTED 10d869: 8b 15 80 ca 11 00 mov 0x11ca80,%edx <== NOT EXECUTED 10d86f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d871: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10d874: a1 a4 cb 11 00 mov 0x11cba4,%eax <== NOT EXECUTED 10d879: 85 c0 test %eax,%eax <== NOT EXECUTED 10d87b: 74 05 je 10d882 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10d87d: ff d0 call *%eax <== NOT EXECUTED 10d87f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10d882: 53 push %ebx <== NOT EXECUTED 10d883: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10d884: 50 push %eax <== NOT EXECUTED 10d885: 50 push %eax <== NOT EXECUTED 10d886: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d889: 50 push %eax <== NOT EXECUTED 10d88a: 56 push %esi <== NOT EXECUTED 10d88b: e8 58 e0 ff ff call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 10d890: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d893: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d896: 5b pop %ebx <== NOT EXECUTED 10d897: 5e pop %esi <== NOT EXECUTED 10d898: c9 leave <== NOT EXECUTED 10d899: c3 ret <== NOT EXECUTED 00109ec4 <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 109ec4: 55 push %ebp <== NOT EXECUTED 109ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 109ec7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109eca: a3 9c cb 11 00 mov %eax,0x11cb9c <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 109ecf: c7 05 90 ca 11 00 00 movl $0x21dae500,0x11ca90 <== NOT EXECUTED 109ed6: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 109ed9: c7 05 94 ca 11 00 00 movl $0x0,0x11ca94 <== NOT EXECUTED 109ee0: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 109ee3: c7 05 7c ca 11 00 00 movl $0x0,0x11ca7c <== NOT EXECUTED 109eea: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 109eed: c7 05 80 ca 11 00 00 movl $0x0,0x11ca80 <== NOT EXECUTED 109ef4: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 109ef7: c6 05 14 ca 11 00 00 movb $0x0,0x11ca14 <== NOT EXECUTED _TOD_Activate(); } 109efe: c9 leave <== NOT EXECUTED 109eff: c3 ret <== NOT EXECUTED 0010b0f4 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10b0f4: 55 push %ebp <== NOT EXECUTED 10b0f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0f7: 53 push %ebx <== NOT EXECUTED 10b0f8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0fb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b0fe: a1 bc 83 12 00 mov 0x1283bc,%eax <== NOT EXECUTED 10b103: 40 inc %eax <== NOT EXECUTED 10b104: a3 bc 83 12 00 mov %eax,0x1283bc <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10b109: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b10b: a1 4c 84 12 00 mov 0x12844c,%eax <== NOT EXECUTED 10b110: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b112: 7d 08 jge 10b11c <_TOD_Set+0x28> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10b114: 51 push %ecx <== NOT EXECUTED 10b115: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b117: 50 push %eax <== NOT EXECUTED 10b118: 6a 01 push $0x1 <== NOT EXECUTED 10b11a: eb 06 jmp 10b122 <_TOD_Set+0x2e> <== NOT EXECUTED 10b11c: 51 push %ecx <== NOT EXECUTED 10b11d: 29 c2 sub %eax,%edx <== NOT EXECUTED 10b11f: 52 push %edx <== NOT EXECUTED 10b120: 6a 00 push $0x0 <== NOT EXECUTED 10b122: 68 90 84 12 00 push $0x128490 <== NOT EXECUTED 10b127: e8 68 20 00 00 call 10d194 <_Watchdog_Adjust> <== NOT EXECUTED 10b12c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 10b12f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b131: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b134: a3 50 84 12 00 mov %eax,0x128450 <== NOT EXECUTED 10b139: 89 15 4c 84 12 00 mov %edx,0x12844c <== NOT EXECUTED _TOD_Is_set = TRUE; 10b13f: c6 05 d0 83 12 00 01 movb $0x1,0x1283d0 <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10b146: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b149: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10b14a: e9 f1 0f 00 00 jmp 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 00109f00 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 109f00: 55 push %ebp <== NOT EXECUTED 109f01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f03: 53 push %ebx <== NOT EXECUTED 109f04: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED struct timespec tick; uint32_t seconds; /* Convert the tick quantum to a timespec */ tick.tv_nsec = _TOD_Microseconds_per_tick * 1000; 109f07: 69 05 9c cb 11 00 e8 imul $0x3e8,0x11cb9c,%eax <== NOT EXECUTED 109f0e: 03 00 00 <== NOT EXECUTED 109f11: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 109f14: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 109f1b: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 109f20: 40 inc %eax <== NOT EXECUTED 109f21: a3 50 cb 11 00 mov %eax,0x11cb50 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 109f26: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 109f29: 53 push %ebx <== NOT EXECUTED 109f2a: 68 7c ca 11 00 push $0x11ca7c <== NOT EXECUTED 109f2f: e8 b4 19 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); 109f34: 58 pop %eax <== NOT EXECUTED 109f35: 5a pop %edx <== NOT EXECUTED 109f36: 53 push %ebx <== NOT EXECUTED 109f37: 68 90 ca 11 00 push $0x11ca90 <== NOT EXECUTED 109f3c: e8 a7 19 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 109f41: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109f43: eb 0e jmp 109f53 <_TOD_Tickle_ticks+0x53> <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 109f45: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f48: 68 d4 ca 11 00 push $0x11cad4 <== NOT EXECUTED 109f4d: e8 8a 1d 00 00 call 10bcdc <_Watchdog_Tickle> <== NOT EXECUTED while ( seconds ) { _Watchdog_Tickle_seconds(); seconds--; 109f52: 4b dec %ebx <== NOT EXECUTED 109f53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); while ( seconds ) { 109f56: 85 db test %ebx,%ebx <== NOT EXECUTED 109f58: 75 eb jne 109f45 <_TOD_Tickle_ticks+0x45> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 109f5a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109f5d: c9 leave <== NOT EXECUTED 109f5e: c3 ret <== NOT EXECUTED 001099d0 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( rtems_time_of_day *the_tod ) { 1099d0: 55 push %ebp <== NOT EXECUTED 1099d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099d3: 56 push %esi <== NOT EXECUTED 1099d4: 53 push %ebx <== NOT EXECUTED 1099d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 1099d8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1099db: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED year_mod_4 = the_tod->year & 3; 1099de: 8b 13 mov (%ebx),%edx <== NOT EXECUTED if ( year_mod_4 == 0 ) 1099e0: 89 d6 mov %edx,%esi <== NOT EXECUTED 1099e2: 83 e6 03 and $0x3,%esi <== NOT EXECUTED 1099e5: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1099e8: 75 0a jne 1099f4 <_TOD_To_seconds+0x24> <== NOT EXECUTED time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 1099ea: 0f b7 84 00 5a 98 11 movzwl 0x11985a(%eax,%eax,1),%eax <== NOT EXECUTED 1099f1: 00 <== NOT EXECUTED 1099f2: eb 08 jmp 1099fc <_TOD_To_seconds+0x2c> <== NOT EXECUTED else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 1099f4: 0f b7 84 00 40 98 11 movzwl 0x119840(%eax,%eax,1),%eax <== NOT EXECUTED 1099fb: 00 <== NOT EXECUTED 1099fc: 8d 0c 08 lea (%eax,%ecx,1),%ecx <== NOT EXECUTED time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 1099ff: 0f b7 84 36 74 98 11 movzwl 0x119874(%esi,%esi,1),%eax <== NOT EXECUTED 109a06: 00 <== NOT EXECUTED 109a07: 81 ea c4 07 00 00 sub $0x7c4,%edx <== NOT EXECUTED 109a0d: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 109a10: 69 d2 b5 05 00 00 imul $0x5b5,%edx,%edx <== NOT EXECUTED 109a16: 01 d0 add %edx,%eax <== NOT EXECUTED ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 109a18: 01 c8 add %ecx,%eax <== NOT EXECUTED time *= TOD_SECONDS_PER_DAY; 109a1a: 69 c0 80 51 01 00 imul $0x15180,%eax,%eax <== NOT EXECUTED time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 109a20: 6b 53 0c 3c imul $0x3c,0xc(%ebx),%edx <== NOT EXECUTED 109a24: 03 53 10 add 0x10(%ebx),%edx <== NOT EXECUTED 109a27: 6b d2 3c imul $0x3c,%edx,%edx <== NOT EXECUTED 109a2a: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 109a2d: 8d 84 10 00 e5 da 21 lea 0x21dae500(%eax,%edx,1),%eax <== NOT EXECUTED time += TOD_SECONDS_1970_THROUGH_1988; return( time ); } 109a34: 5b pop %ebx <== NOT EXECUTED 109a35: 5e pop %esi <== NOT EXECUTED 109a36: c9 leave <== NOT EXECUTED 109a37: c3 ret <== NOT EXECUTED 00109a38 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 109a38: 55 push %ebp <== NOT EXECUTED 109a39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a3b: 53 push %ebx <== NOT EXECUTED 109a3c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109a3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t days_in_month; if ((!the_tod) || 109a42: 85 db test %ebx,%ebx <== NOT EXECUTED 109a44: 74 5d je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a46: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109a4b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a4d: f7 35 58 85 12 00 divl 0x128558 <== NOT EXECUTED 109a53: 39 43 18 cmp %eax,0x18(%ebx) <== NOT EXECUTED 109a56: 73 4b jae 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a58: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) <== NOT EXECUTED 109a5c: 77 45 ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a5e: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) <== NOT EXECUTED 109a62: 77 3f ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a64: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) <== NOT EXECUTED 109a68: 77 39 ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a6a: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 109a6d: 85 c0 test %eax,%eax <== NOT EXECUTED 109a6f: 74 32 je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a71: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 109a74: 77 2d ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a76: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 109a78: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx <== NOT EXECUTED 109a7e: 76 23 jbe 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a80: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 109a83: 85 d2 test %edx,%edx <== NOT EXECUTED 109a85: 74 1c je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 109a87: 80 e1 03 and $0x3,%cl <== NOT EXECUTED 109a8a: 75 09 jne 109a95 <_TOD_Validate+0x5d> <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 109a8c: 8b 04 85 b0 98 11 00 mov 0x1198b0(,%eax,4),%eax <== NOT EXECUTED 109a93: eb 07 jmp 109a9c <_TOD_Validate+0x64> <== NOT EXECUTED else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 109a95: 8b 04 85 7c 98 11 00 mov 0x11987c(,%eax,4),%eax <== NOT EXECUTED 109a9c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 109a9e: 0f 96 c0 setbe %al <== NOT EXECUTED 109aa1: eb 02 jmp 109aa5 <_TOD_Validate+0x6d> <== NOT EXECUTED 109aa3: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 109aa5: 5a pop %edx <== NOT EXECUTED 109aa6: 5b pop %ebx <== NOT EXECUTED 109aa7: c9 leave <== NOT EXECUTED 109aa8: c3 ret <== NOT EXECUTED 0010a920 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10a920: 55 push %ebp <== NOT EXECUTED 10a921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a923: 57 push %edi <== NOT EXECUTED 10a924: 56 push %esi <== NOT EXECUTED 10a925: 53 push %ebx <== NOT EXECUTED 10a926: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a929: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a92c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a92f: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10a932: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10a935: 8b 7b 10 mov 0x10(%ebx),%edi <== NOT EXECUTED /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10a938: 53 push %ebx <== NOT EXECUTED 10a939: e8 3e 0d 00 00 call 10b67c <_Thread_Set_transient> <== NOT EXECUTED /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10a93e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a941: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10a944: 74 0c je 10a952 <_Thread_Change_priority+0x32> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10a946: 50 push %eax <== NOT EXECUTED 10a947: 50 push %eax <== NOT EXECUTED 10a948: 56 push %esi <== NOT EXECUTED 10a949: 53 push %ebx <== NOT EXECUTED 10a94a: e8 f9 0b 00 00 call 10b548 <_Thread_Set_priority> <== NOT EXECUTED 10a94f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10a952: 9c pushf <== NOT EXECUTED 10a953: fa cli <== NOT EXECUTED 10a954: 5e pop %esi <== NOT EXECUTED /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10a955: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10a958: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10a95b: 74 30 je 10a98d <_Thread_Change_priority+0x6d> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10a95d: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10a960: 75 08 jne 10a96a <_Thread_Change_priority+0x4a> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10a962: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a964: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10a967: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a96a: 56 push %esi <== NOT EXECUTED 10a96b: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10a96c: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10a972: 0f 84 c0 00 00 00 je 10aa38 <_Thread_Change_priority+0x118> <== NOT EXECUTED _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10a978: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10a97b: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10a97e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10a981: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a984: 5b pop %ebx <== NOT EXECUTED 10a985: 5e pop %esi <== NOT EXECUTED 10a986: 5f pop %edi <== NOT EXECUTED 10a987: c9 leave <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10a988: e9 33 0b 00 00 jmp 10b4c0 <_Thread_queue_Requeue> <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10a98d: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10a990: 75 53 jne 10a9e5 <_Thread_Change_priority+0xc5> <== NOT EXECUTED * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10a992: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10a999: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10a99f: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10a9a6: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10a9a9: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10a9af: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10a9b5: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10a9bb: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10a9bf: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED 10a9c5: 74 0e je 10a9d5 <_Thread_Change_priority+0xb5> <== NOT EXECUTED 10a9c7: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10a9ca: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10a9cc: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10a9ce: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10a9d0: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 10a9d3: eb 10 jmp 10a9e5 <_Thread_Change_priority+0xc5> <== NOT EXECUTED 10a9d5: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10a9d8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10a9da: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10a9dd: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10a9e0: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10a9e2: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10a9e5: 56 push %esi <== NOT EXECUTED 10a9e6: 9d popf <== NOT EXECUTED 10a9e7: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10a9e8: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10a9ef: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a9f1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a9f3: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10a9f7: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10a9fa: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10aa01: 00 <== NOT EXECUTED 10aa02: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10aa06: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10aa09: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10aa0c: 01 d0 add %edx,%eax <== NOT EXECUTED 10aa0e: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10aa11: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10aa17: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10aa1a: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10aa1f: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 10aa25: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aa27: 74 0d je 10aa36 <_Thread_Change_priority+0x116> <== NOT EXECUTED 10aa29: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10aa2d: 74 07 je 10aa36 <_Thread_Change_priority+0x116> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10aa2f: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10aa36: 56 push %esi <== NOT EXECUTED 10aa37: 9d popf <== NOT EXECUTED } 10aa38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa3b: 5b pop %ebx <== NOT EXECUTED 10aa3c: 5e pop %esi <== NOT EXECUTED 10aa3d: 5f pop %edi <== NOT EXECUTED 10aa3e: c9 leave <== NOT EXECUTED 10aa3f: c3 ret <== NOT EXECUTED 0010aa40 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 53 push %ebx <== NOT EXECUTED 10aa44: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aa47: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10aa4a: 9c pushf <== NOT EXECUTED 10aa4b: fa cli <== NOT EXECUTED 10aa4c: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10aa4d: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10aa50: 85 d0 test %edx,%eax <== NOT EXECUTED 10aa52: 74 6f je 10aac3 <_Thread_Clear_state+0x83> <== 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( 10aa54: f7 d0 not %eax <== NOT EXECUTED 10aa56: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10aa58: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10aa5b: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa5d: 75 64 jne 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10aa5f: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10aa65: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10aa6c: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10aa6f: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10aa75: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10aa7b: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10aa81: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10aa87: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10aa8a: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10aa8c: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10aa8f: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10aa92: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10aa94: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10aa97: 53 push %ebx <== NOT EXECUTED 10aa98: 9d popf <== NOT EXECUTED 10aa99: fa cli <== NOT EXECUTED * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10aa9a: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10aa9d: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10aaa2: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10aaa5: 73 1c jae 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED _Thread_Heir = the_thread; 10aaa7: 89 0d 8c ca 11 00 mov %ecx,0x11ca8c <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10aaad: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10aab2: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10aab6: 75 04 jne 10aabc <_Thread_Clear_state+0x7c> <== NOT EXECUTED 10aab8: 85 d2 test %edx,%edx <== NOT EXECUTED 10aaba: 75 07 jne 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10aabc: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED } } } _ISR_Enable( level ); 10aac3: 53 push %ebx <== NOT EXECUTED 10aac4: 9d popf <== NOT EXECUTED } 10aac5: 5b pop %ebx <== NOT EXECUTED 10aac6: c9 leave <== NOT EXECUTED 10aac7: c3 ret <== NOT EXECUTED 0010aac8 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10aac8: 55 push %ebp <== NOT EXECUTED 10aac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aacb: 56 push %esi <== NOT EXECUTED 10aacc: 53 push %ebx <== NOT EXECUTED 10aacd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10aad0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aad3: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10aad7: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10aada: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10aae1: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10aae6: 48 dec %eax <== NOT EXECUTED 10aae7: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10aaec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaef: 56 push %esi <== NOT EXECUTED 10aaf0: e8 c3 0f 00 00 call 10bab8 <_User_extensions_Thread_delete> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10aaf5: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10aafa: 40 inc %eax <== NOT EXECUTED 10aafb: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED /* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object ); 10ab00: 59 pop %ecx <== NOT EXECUTED 10ab01: 58 pop %eax <== NOT EXECUTED 10ab02: 56 push %esi <== NOT EXECUTED 10ab03: 53 push %ebx <== NOT EXECUTED 10ab04: e8 27 f7 ff ff call 10a230 <_Objects_Close> <== NOT EXECUTED /* * By setting the dormant state, the thread will not be considered * for scheduling when we remove any blocking states. */ _Thread_Set_state( the_thread, STATES_DORMANT ); 10ab09: 58 pop %eax <== NOT EXECUTED 10ab0a: 5a pop %edx <== NOT EXECUTED 10ab0b: 6a 01 push $0x1 <== NOT EXECUTED 10ab0d: 56 push %esi <== NOT EXECUTED 10ab0e: e8 9d 0a 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10ab13: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ab16: e8 d9 08 00 00 call 10b3f4 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10ab1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab1e: 84 c0 test %al,%al <== NOT EXECUTED 10ab20: 75 15 jne 10ab37 <_Thread_Close+0x6f> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10ab22: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10ab26: 75 0f jne 10ab37 <_Thread_Close+0x6f> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10ab28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab2b: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10ab2e: 50 push %eax <== NOT EXECUTED 10ab2f: e8 40 11 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10ab34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * The thread might have been FP. So deal with that. */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( _Thread_Is_allocated_fp( the_thread ) ) 10ab37: 3b 35 84 ca 11 00 cmp 0x11ca84,%esi <== NOT EXECUTED 10ab3d: 75 0a jne 10ab49 <_Thread_Close+0x81> <== NOT EXECUTED * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( 10ab3f: c7 05 84 ca 11 00 00 movl $0x0,0x11ca84 <== NOT EXECUTED 10ab46: 00 00 00 <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10ab49: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10ab50: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10ab53: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10ab59: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab5b: 74 0c je 10ab69 <_Thread_Close+0xa1> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10ab5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab60: 50 push %eax <== NOT EXECUTED 10ab61: e8 e2 11 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10ab66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); 10ab69: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab6c: 56 push %esi <== NOT EXECUTED 10ab6d: e8 ca 0b 00 00 call 10b73c <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10ab72: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10ab79: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10ab7c: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10ab82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab85: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab87: 74 0c je 10ab95 <_Thread_Close+0xcd> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10ab89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab8c: 50 push %eax <== NOT EXECUTED 10ab8d: e8 b6 11 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10ab92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10ab95: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10ab9c: 00 00 00 <== NOT EXECUTED } 10ab9f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aba2: 5b pop %ebx <== NOT EXECUTED 10aba3: 5e pop %esi <== NOT EXECUTED 10aba4: c9 leave <== NOT EXECUTED 10aba5: c3 ret <== NOT EXECUTED 0010aba8 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10aba8: 55 push %ebp <== NOT EXECUTED 10aba9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abab: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10abae: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10abb3: e8 04 f6 ff ff call 10a1bc <_Objects_Allocate> <== NOT EXECUTED /* * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 10abb8: a3 a8 cb 11 00 mov %eax,0x11cba8 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10abbd: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10abc2: 40 inc %eax <== NOT EXECUTED 10abc3: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10abc8: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10abcd: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10abd0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10abd3: 68 58 68 11 00 push $0x116858 <== NOT EXECUTED 10abd8: 6a 00 push $0x0 <== NOT EXECUTED 10abda: 6a 00 push $0x0 <== NOT EXECUTED 10abdc: 6a 00 push $0x0 <== NOT EXECUTED 10abde: 6a 01 push $0x1 <== NOT EXECUTED 10abe0: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10abe7: 50 push %eax <== NOT EXECUTED 10abe8: 6a 00 push $0x0 <== NOT EXECUTED 10abea: a1 80 86 11 00 mov 0x118680,%eax <== NOT EXECUTED 10abef: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10abf1: 73 02 jae 10abf5 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10abf3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10abf5: 50 push %eax <== NOT EXECUTED 10abf6: 6a 00 push $0x0 <== NOT EXECUTED 10abf8: ff 35 a8 cb 11 00 pushl 0x11cba8 <== NOT EXECUTED 10abfe: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10ac03: e8 50 02 00 00 call 10ae58 <_Thread_Initialize> <== NOT EXECUTED 10ac08: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10ac0d: 48 dec %eax <== NOT EXECUTED 10ac0e: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10ac13: 8b 15 a8 cb 11 00 mov 0x11cba8,%edx <== NOT EXECUTED 10ac19: 89 15 c0 ca 11 00 mov %edx,0x11cac0 <== NOT EXECUTED 10ac1f: 89 15 8c ca 11 00 mov %edx,0x11ca8c <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10ac25: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10ac28: 6a 00 push $0x0 <== NOT EXECUTED 10ac2a: 6a 00 push $0x0 <== NOT EXECUTED 10ac2c: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10ac31: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10ac34: 6a 00 push $0x0 <== NOT EXECUTED 10ac36: 52 push %edx <== NOT EXECUTED 10ac37: e8 8c 0b 00 00 call 10b7c8 <_Thread_Start> <== NOT EXECUTED 10ac3c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10ac3f: c9 leave <== NOT EXECUTED 10ac40: c3 ret <== NOT EXECUTED 0010ac44 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10ac44: 55 push %ebp <== NOT EXECUTED 10ac45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac47: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ac4a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ac4d: 50 push %eax <== NOT EXECUTED 10ac4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ac51: e8 8a 01 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10ac56: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac59: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10ac5d: 75 1b jne 10ac7a <_Thread_Delay_ended+0x36> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10ac5f: 52 push %edx <== NOT EXECUTED 10ac60: 52 push %edx <== NOT EXECUTED 10ac61: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10ac66: 50 push %eax <== NOT EXECUTED 10ac67: e8 d4 fd ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10ac6c: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10ac71: 48 dec %eax <== NOT EXECUTED 10ac72: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10ac77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10ac7a: c9 leave <== NOT EXECUTED 10ac7b: c3 ret <== NOT EXECUTED 0010ac7c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10ac7c: 55 push %ebp <== NOT EXECUTED 10ac7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac7f: 57 push %edi <== NOT EXECUTED 10ac80: 56 push %esi <== NOT EXECUTED 10ac81: 53 push %ebx <== NOT EXECUTED 10ac82: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10ac85: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ac8b: 9c pushf <== NOT EXECUTED 10ac8c: fa cli <== NOT EXECUTED 10ac8d: 5a pop %edx <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10ac8e: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ac91: e9 f1 00 00 00 jmp 10ad87 <_Thread_Dispatch+0x10b> <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; 10ac96: 8b 35 8c ca 11 00 mov 0x11ca8c,%esi <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10ac9c: c7 05 00 ca 11 00 01 movl $0x1,0x11ca00 <== NOT EXECUTED 10aca3: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10aca6: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = heir; 10acad: 89 35 c0 ca 11 00 mov %esi,0x11cac0 <== NOT EXECUTED #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10acb3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) <== NOT EXECUTED 10acb7: 75 08 jne 10acc1 <_Thread_Dispatch+0x45> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10acb9: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10acbe: 89 46 78 mov %eax,0x78(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10acc1: 52 push %edx <== NOT EXECUTED 10acc2: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10acc3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acc6: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10acc9: 50 push %eax <== NOT EXECUTED 10acca: e8 79 2b 00 00 call 10d848 <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10accf: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10acd2: 57 push %edi <== NOT EXECUTED 10acd3: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10acd6: 50 push %eax <== NOT EXECUTED 10acd7: 68 c8 ca 11 00 push $0x11cac8 <== NOT EXECUTED 10acdc: e8 37 0c 00 00 call 10b918 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10ace1: 58 pop %eax <== NOT EXECUTED 10ace2: 5a pop %edx <== NOT EXECUTED 10ace3: 57 push %edi <== NOT EXECUTED 10ace4: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax <== NOT EXECUTED 10acea: 50 push %eax <== NOT EXECUTED 10aceb: e8 f8 0b 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10acf0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10acf3: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10acf6: a3 c8 ca 11 00 mov %eax,0x11cac8 <== NOT EXECUTED 10acfb: 89 15 cc ca 11 00 mov %edx,0x11cacc <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10ad01: 8b 15 88 ca 11 00 mov 0x11ca88,%edx <== NOT EXECUTED 10ad07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad0a: 85 d2 test %edx,%edx <== NOT EXECUTED 10ad0c: 74 10 je 10ad1e <_Thread_Dispatch+0xa2> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10ad0e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ad10: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10ad16: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax <== NOT EXECUTED 10ad1c: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10ad1e: 51 push %ecx <== NOT EXECUTED 10ad1f: 51 push %ecx <== NOT EXECUTED 10ad20: 56 push %esi <== NOT EXECUTED 10ad21: 53 push %ebx <== NOT EXECUTED 10ad22: e8 01 0e 00 00 call 10bb28 <_User_extensions_Thread_switch> <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10ad27: 58 pop %eax <== NOT EXECUTED 10ad28: 5a pop %edx <== NOT EXECUTED 10ad29: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10ad2f: 50 push %eax <== NOT EXECUTED 10ad30: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10ad36: 50 push %eax <== NOT EXECUTED 10ad37: e8 b4 10 00 00 call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10ad3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad3f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10ad46: 74 36 je 10ad7e <_Thread_Dispatch+0x102> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ad48: a1 84 ca 11 00 mov 0x11ca84,%eax <== NOT EXECUTED 10ad4d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ad4f: 74 2d je 10ad7e <_Thread_Dispatch+0x102> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10ad51: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad53: 74 11 je 10ad66 <_Thread_Dispatch+0xea> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ad55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad58: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10ad5d: 50 push %eax <== NOT EXECUTED 10ad5e: e8 c1 10 00 00 call 10be24 <_CPU_Context_save_fp> <== NOT EXECUTED 10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10ad66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad69: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10ad6f: 50 push %eax <== NOT EXECUTED 10ad70: e8 b9 10 00 00 call 10be2e <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ad75: 89 1d 84 ca 11 00 mov %ebx,0x11ca84 <== NOT EXECUTED 10ad7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10ad7e: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ad84: 9c pushf <== NOT EXECUTED 10ad85: fa cli <== NOT EXECUTED 10ad86: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10ad87: a0 d0 ca 11 00 mov 0x11cad0,%al <== NOT EXECUTED 10ad8c: 84 c0 test %al,%al <== NOT EXECUTED 10ad8e: 0f 85 02 ff ff ff jne 10ac96 <_Thread_Dispatch+0x1a> <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10ad94: c7 05 00 ca 11 00 00 movl $0x0,0x11ca00 <== NOT EXECUTED 10ad9b: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10ad9e: 52 push %edx <== NOT EXECUTED 10ad9f: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10ada0: 83 3d a4 ca 11 00 00 cmpl $0x0,0x11caa4 <== NOT EXECUTED 10ada7: 75 06 jne 10adaf <_Thread_Dispatch+0x133> <== NOT EXECUTED 10ada9: 80 7b 75 00 cmpb $0x0,0x75(%ebx) <== NOT EXECUTED 10adad: 74 09 je 10adb8 <_Thread_Dispatch+0x13c> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10adaf: c6 43 75 00 movb $0x0,0x75(%ebx) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10adb3: e8 4b eb ff ff call 109903 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10adb8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adbb: 5b pop %ebx <== NOT EXECUTED 10adbc: 5e pop %esi <== NOT EXECUTED 10adbd: 5f pop %edi <== NOT EXECUTED 10adbe: c9 leave <== NOT EXECUTED 10adbf: c3 ret <== NOT EXECUTED 0010adc0 <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10adc0: 55 push %ebp <== NOT EXECUTED 10adc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10adc3: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10adc8: 48 dec %eax <== NOT EXECUTED 10adc9: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10adce: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10add3: 85 c0 test %eax,%eax <== NOT EXECUTED 10add5: 75 06 jne 10addd <_Thread_Enable_dispatch+0x1d> <== NOT EXECUTED return; _Thread_Dispatch(); } 10add7: c9 leave <== NOT EXECUTED (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { if ( --_Thread_Dispatch_disable_level ) return; _Thread_Dispatch(); 10add8: e9 9f fe ff ff jmp 10ac7c <_Thread_Dispatch> <== NOT EXECUTED } 10addd: c9 leave <== NOT EXECUTED 10adde: c3 ret <== NOT EXECUTED 0010e4e8 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10e4e8: 55 push %ebp <== NOT EXECUTED 10e4e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10e4eb: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 10e4f0: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10e4f4: 75 0e jne 10e504 <_Thread_Evaluate_mode+0x1c> <== NOT EXECUTED 10e4f6: 3b 05 8c ca 11 00 cmp 0x11ca8c,%eax <== NOT EXECUTED 10e4fc: 74 11 je 10e50f <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED 10e4fe: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e502: 74 0b je 10e50f <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10e504: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED 10e50b: b0 01 mov $0x1,%al <== NOT EXECUTED 10e50d: eb 02 jmp 10e511 <_Thread_Evaluate_mode+0x29> <== NOT EXECUTED return TRUE; 10e50f: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 10e511: c9 leave <== NOT EXECUTED 10e512: c3 ret <== NOT EXECUTED 0010ade0 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10ade0: 55 push %ebp <== NOT EXECUTED 10ade1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ade3: 53 push %ebx <== NOT EXECUTED 10ade4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ade7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10adea: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10aded: 85 db test %ebx,%ebx <== NOT EXECUTED 10adef: 75 18 jne 10ae09 <_Thread_Get+0x29> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10adf1: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10adf6: 40 inc %eax <== NOT EXECUTED 10adf7: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10adfc: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED tp = _Thread_Executing; 10ae02: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10ae07: eb 40 jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10ae09: 89 da mov %ebx,%edx <== NOT EXECUTED 10ae0b: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10ae0e: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10ae11: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10ae14: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ae17: 76 35 jbe 10ae4e <_Thread_Get+0x6e> <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10ae19: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10ae1f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae21: eb 26 jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } api_information = _Objects_Information_table[ the_api ]; 10ae23: 8b 04 95 d4 c9 11 00 mov 0x11c9d4(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10ae2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2c: 74 07 je 10ae35 <_Thread_Get+0x55> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10ae2e: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10ae31: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae33: 75 08 jne 10ae3d <_Thread_Get+0x5d> <== NOT EXECUTED *location = OBJECTS_ERROR; 10ae35: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10ae3b: eb 0c jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10ae3d: 52 push %edx <== NOT EXECUTED 10ae3e: 51 push %ecx <== NOT EXECUTED 10ae3f: 53 push %ebx <== NOT EXECUTED 10ae40: 50 push %eax <== NOT EXECUTED 10ae41: e8 ba f7 ff ff call 10a600 <_Objects_Get> <== NOT EXECUTED 10ae46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10ae49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae4c: c9 leave <== NOT EXECUTED 10ae4d: c3 ret <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10ae4e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ae50: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10ae53: 48 dec %eax <== NOT EXECUTED 10ae54: 74 cd je 10ae23 <_Thread_Get+0x43> <== NOT EXECUTED 10ae56: eb c1 jmp 10ae19 <_Thread_Get+0x39> <== NOT EXECUTED 0010e514 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10e514: 55 push %ebp <== NOT EXECUTED 10e515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e517: 53 push %ebx <== NOT EXECUTED 10e518: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 10e51b: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10e521: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 10e527: 85 c0 test %eax,%eax <== NOT EXECUTED 10e529: 74 03 je 10e52e <_Thread_Handler+0x1a> <== NOT EXECUTED 10e52b: fa cli <== NOT EXECUTED 10e52c: eb 01 jmp 10e52f <_Thread_Handler+0x1b> <== NOT EXECUTED 10e52e: fb sti <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10e52f: a0 f8 c7 11 00 mov 0x11c7f8,%al <== NOT EXECUTED 10e534: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 10e537: c6 05 f8 c7 11 00 01 movb $0x1,0x11c7f8 <== NOT EXECUTED #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) { 10e53e: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10e545: 74 24 je 10e56b <_Thread_Handler+0x57> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10e547: a1 84 ca 11 00 mov 0x11ca84,%eax <== NOT EXECUTED 10e54c: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10e54e: 74 1b je 10e56b <_Thread_Handler+0x57> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 10e550: 85 c0 test %eax,%eax <== NOT EXECUTED 10e552: 74 11 je 10e565 <_Thread_Handler+0x51> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10e554: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e557: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10e55c: 50 push %eax <== NOT EXECUTED 10e55d: e8 c2 d8 ff ff call 10be24 <_CPU_Context_save_fp> <== NOT EXECUTED 10e562: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 10e565: 89 1d 84 ca 11 00 mov %ebx,0x11ca84 <== NOT EXECUTED * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 10e56b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e56e: 53 push %ebx <== NOT EXECUTED 10e56f: e8 68 d4 ff ff call 10b9dc <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 10e574: e8 47 c8 ff ff call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ 10e579: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e57c: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 10e580: 75 05 jne 10e587 <_Thread_Handler+0x73> <== NOT EXECUTED { _init (); 10e582: e8 69 6e 00 00 call 1153f0 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 10e587: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 10e58d: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10e590: 74 13 je 10e5a5 <_Thread_Handler+0x91> <== NOT EXECUTED 10e592: 72 0c jb 10e5a0 <_Thread_Handler+0x8c> <== NOT EXECUTED 10e594: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10e597: 74 11 je 10e5aa <_Thread_Handler+0x96> <== NOT EXECUTED 10e599: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10e59c: 75 36 jne 10e5d4 <_Thread_Handler+0xc0> <== NOT EXECUTED 10e59e: eb 1a jmp 10e5ba <_Thread_Handler+0xa6> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 10e5a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5a3: eb 1d jmp 10e5c2 <_Thread_Handler+0xae> <== NOT EXECUTED (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 10e5a5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5a8: eb 08 jmp 10e5b2 <_Thread_Handler+0x9e> <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 10e5aa: 52 push %edx <== NOT EXECUTED 10e5ab: 52 push %edx <== NOT EXECUTED 10e5ac: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10e5b2: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10e5b8: eb 0e jmp 10e5c8 <_Thread_Handler+0xb4> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 10e5ba: 50 push %eax <== NOT EXECUTED 10e5bb: 50 push %eax <== NOT EXECUTED 10e5bc: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10e5c2: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10e5c8: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 10e5ce: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 10e5d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 10e5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5d7: 53 push %ebx <== NOT EXECUTED 10e5d8: e8 30 d4 ff ff call 10ba0d <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 10e5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e5e0: 6a 06 push $0x6 <== NOT EXECUTED 10e5e2: 6a 01 push $0x1 <== NOT EXECUTED 10e5e4: 6a 00 push $0x0 <== NOT EXECUTED 10e5e6: e8 3d bb ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 0010b02c <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10b02c: 55 push %ebp <== NOT EXECUTED 10b02d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b02f: 53 push %ebx <== NOT EXECUTED 10b030: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( (!_Configuration_Table->stack_allocate_hook) 10b033: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b038: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 10b03c: 0f 94 c2 sete %dl <== NOT EXECUTED 10b03f: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 10b043: 0f 94 c0 sete %al <== NOT EXECUTED 10b046: 38 c2 cmp %al,%dl <== NOT EXECUTED 10b048: 74 0c je 10b056 <_Thread_Handler_initialization+0x2a> <== NOT EXECUTED == (!_Configuration_Table->stack_free_hook) ) ) _Internal_error_Occurred( 10b04a: 52 push %edx <== NOT EXECUTED 10b04b: 6a 0f push $0xf <== NOT EXECUTED 10b04d: 6a 01 push $0x1 <== NOT EXECUTED 10b04f: 6a 00 push $0x0 <== NOT EXECUTED 10b051: e8 d2 f0 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10b056: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = NULL; 10b05d: c7 05 c0 ca 11 00 00 movl $0x0,0x11cac0 <== NOT EXECUTED 10b064: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10b067: c7 05 8c ca 11 00 00 movl $0x0,0x11ca8c <== NOT EXECUTED 10b06e: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10b071: c7 05 84 ca 11 00 00 movl $0x0,0x11ca84 <== NOT EXECUTED 10b078: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10b07b: c7 05 a4 ca 11 00 00 movl $0x0,0x11caa4 <== NOT EXECUTED 10b082: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10b085: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b088: a3 a0 ca 11 00 mov %eax,0x11caa0 <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10b08d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b090: a3 cc c9 11 00 mov %eax,0x11c9cc <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10b095: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b098: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10b09f: 40 inc %eax <== NOT EXECUTED 10b0a0: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b0a3: 50 push %eax <== NOT EXECUTED 10b0a4: e8 c9 0c 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b0a9: a3 c8 c9 11 00 mov %eax,0x11c9c8 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10b0ae: 0f b6 1d 84 86 11 00 movzbl 0x118684,%ebx <== NOT EXECUTED 10b0b5: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b0b7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0bc: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b0bf: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b0c1: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b0c8: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10b0cb: 41 inc %ecx <== NOT EXECUTED 10b0cc: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10b0cf: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10b0d1: 76 e9 jbe 10b0bc <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10b0d3: 50 push %eax <== NOT EXECUTED 10b0d4: 6a 08 push $0x8 <== NOT EXECUTED 10b0d6: 6a 01 push $0x1 <== NOT EXECUTED 10b0d8: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10b0dd: 6a 01 push $0x1 <== NOT EXECUTED 10b0df: 6a 01 push $0x1 <== NOT EXECUTED 10b0e1: 6a 01 push $0x1 <== NOT EXECUTED 10b0e3: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10b0e8: e8 6b f5 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10b0ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10b0f0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0f3: c9 leave <== NOT EXECUTED 10b0f4: c3 ret <== NOT EXECUTED 0010ae58 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10ae58: 55 push %ebp <== NOT EXECUTED 10ae59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae5b: 57 push %edi <== NOT EXECUTED 10ae5c: 56 push %esi <== NOT EXECUTED 10ae5d: 53 push %ebx <== NOT EXECUTED 10ae5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae61: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ae64: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae67: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10ae6a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10ae6d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10ae70: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ae73: 88 45 f2 mov %al,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10ae76: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae78: 75 2a jne 10aea4 <_Thread_Initialize+0x4c> <== NOT EXECUTED actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10ae7a: 51 push %ecx <== NOT EXECUTED 10ae7b: 51 push %ecx <== NOT EXECUTED 10ae7c: 56 push %esi <== NOT EXECUTED 10ae7d: 53 push %ebx <== NOT EXECUTED 10ae7e: e8 69 08 00 00 call 10b6ec <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10ae83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae86: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae88: 74 04 je 10ae8e <_Thread_Initialize+0x36> <== NOT EXECUTED 10ae8a: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10ae8c: 73 07 jae 10ae95 <_Thread_Initialize+0x3d> <== NOT EXECUTED 10ae8e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ae90: e9 8c 01 00 00 jmp 10b021 <_Thread_Initialize+0x1c9> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10ae95: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10ae9b: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10aea2: eb 09 jmp 10aead <_Thread_Initialize+0x55> <== NOT EXECUTED } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 10aea4: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10aeab: 89 f0 mov %esi,%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 10aead: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10aeb3: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10aeb9: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10aebb: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10aebf: 74 17 je 10aed8 <_Thread_Initialize+0x80> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10aec1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aec4: 6a 6c push $0x6c <== NOT EXECUTED 10aec6: e8 92 0e 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10aecb: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !fp_area ) { 10aecd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aed0: 85 c0 test %eax,%eax <== NOT EXECUTED 10aed2: 0f 84 3b 01 00 00 je 10b013 <_Thread_Initialize+0x1bb> <== NOT EXECUTED fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10aed8: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10aede: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx) <== NOT EXECUTED * 10aee4: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10aeeb: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10aef2: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10aef9: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10af00: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10af07: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10af0a: a1 a0 ca 11 00 mov 0x11caa0,%eax <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10af0f: 31 ff xor %edi,%edi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10af11: 85 c0 test %eax,%eax <== NOT EXECUTED 10af13: 74 1d je 10af32 <_Thread_Initialize+0xda> <== NOT EXECUTED extensions_area = _Workspace_Allocate( 10af15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af18: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10af1f: 50 push %eax <== NOT EXECUTED 10af20: e8 38 0e 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10af25: 89 c7 mov %eax,%edi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10af27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10af2c: 0f 84 d1 00 00 00 je 10b003 <_Thread_Initialize+0x1ab> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10af32: 89 bb 00 01 00 00 mov %edi,0x100(%ebx) <== NOT EXECUTED * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10af38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10af3a: 85 ff test %edi,%edi <== NOT EXECUTED 10af3c: 75 10 jne 10af4e <_Thread_Initialize+0xf6> <== NOT EXECUTED 10af3e: eb 18 jmp 10af58 <_Thread_Initialize+0x100> <== NOT EXECUTED uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) the_thread->extensions[i] = NULL; 10af40: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax <== NOT EXECUTED 10af46: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10af4d: 42 inc %edx <== NOT EXECUTED 10af4e: a1 a0 ca 11 00 mov 0x11caa0,%eax <== NOT EXECUTED 10af53: 40 inc %eax <== NOT EXECUTED 10af54: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10af56: 72 e8 jb 10af40 <_Thread_Initialize+0xe8> <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10af58: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10af5b: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10af61: 8b 45 24 mov 0x24(%ebp),%eax <== NOT EXECUTED 10af64: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10af6a: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10af6d: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10af73: 83 7d 24 02 cmpl $0x2,0x24(%ebp) <== NOT EXECUTED 10af77: 75 08 jne 10af81 <_Thread_Initialize+0x129> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10af79: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10af7e: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10af81: 8b 45 2c mov 0x2c(%ebp),%eax <== NOT EXECUTED 10af84: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10af8a: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10af91: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10af98: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10af9f: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10afa6: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10afa9: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10afac: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10afb2: 52 push %edx <== NOT EXECUTED 10afb3: 52 push %edx <== NOT EXECUTED 10afb4: 50 push %eax <== NOT EXECUTED 10afb5: 53 push %ebx <== NOT EXECUTED 10afb6: e8 8d 05 00 00 call 10b548 <_Thread_Set_priority> <== NOT EXECUTED /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 10afbb: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10afc2: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10afc5: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10afcc: 00 00 00 <== NOT EXECUTED 10afcf: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10afd3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10afd6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10afd9: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10afdc: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10afdf: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 10afe2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10afe5: e8 92 0a 00 00 call 10ba7c <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10afea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afed: b2 01 mov $0x1,%dl <== NOT EXECUTED 10afef: 84 c0 test %al,%al <== NOT EXECUTED 10aff1: 75 2e jne 10b021 <_Thread_Initialize+0x1c9> <== NOT EXECUTED if ( extensions_area ) 10aff3: 85 ff test %edi,%edi <== NOT EXECUTED 10aff5: 74 0c je 10b003 <_Thread_Initialize+0x1ab> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10aff7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10affa: 57 push %edi <== NOT EXECUTED 10affb: e8 48 0d 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10b000: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10b003: 85 f6 test %esi,%esi <== NOT EXECUTED 10b005: 74 0c je 10b013 <_Thread_Initialize+0x1bb> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10b007: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b00a: 56 push %esi <== NOT EXECUTED 10b00b: e8 38 0d 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10b010: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10b013: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b016: 53 push %ebx <== NOT EXECUTED 10b017: e8 20 07 00 00 call 10b73c <_Thread_Stack_Free> <== NOT EXECUTED 10b01c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b01e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10b021: 88 d0 mov %dl,%al <== NOT EXECUTED 10b023: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b026: 5b pop %ebx <== NOT EXECUTED 10b027: 5e pop %esi <== NOT EXECUTED 10b028: 5f pop %edi <== NOT EXECUTED 10b029: c9 leave <== NOT EXECUTED 10b02a: c3 ret <== NOT EXECUTED 0010daa0 <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10daa0: 55 push %ebp <== NOT EXECUTED 10daa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10daa3: 57 push %edi <== NOT EXECUTED 10daa4: 56 push %esi <== NOT EXECUTED 10daa5: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10daa8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED bool is_fp; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( the_thread->Start.fp_context ) { 10daab: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10dab1: 85 ff test %edi,%edi <== NOT EXECUTED 10dab3: 74 12 je 10dac7 <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10dab5: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10dabb: be ac cb 11 00 mov $0x11cbac,%esi <== NOT EXECUTED 10dac0: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10dac5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10dac7: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10dacb: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10dad1: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10dad4: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10dada: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10dadd: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10dae3: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10dae9: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10daf0: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10daf2: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10daf7: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10dafc: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10db02: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10db08: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10db0b: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10db11: c7 00 14 e5 10 00 movl $0x10e514,(%eax) <== NOT EXECUTED 10db17: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10db1d: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10db23: 58 pop %eax <== NOT EXECUTED 10db24: 5e pop %esi <== NOT EXECUTED 10db25: 5f pop %edi <== NOT EXECUTED 10db26: c9 leave <== NOT EXECUTED 10db27: c3 ret <== NOT EXECUTED 0010dd04 <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10dd04: 55 push %ebp <== NOT EXECUTED 10dd05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd07: 53 push %ebx <== NOT EXECUTED 10dd08: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10dd0b: 9c pushf <== NOT EXECUTED 10dd0c: fa cli <== NOT EXECUTED 10dd0d: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10dd0e: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10dd15: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10dd1b: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10dd22: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10dd25: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10dd2b: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10dd31: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10dd37: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10dd3d: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10dd40: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10dd42: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10dd45: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10dd48: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10dd4a: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10dd4d: 53 push %ebx <== NOT EXECUTED 10dd4e: 9d popf <== NOT EXECUTED 10dd4f: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10dd50: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10dd57: 31 d2 xor %edx,%edx <== NOT EXECUTED 10dd59: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dd5b: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10dd5f: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10dd62: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10dd69: 00 <== NOT EXECUTED 10dd6a: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10dd6e: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10dd71: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10dd74: 01 d0 add %edx,%eax <== NOT EXECUTED 10dd76: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10dd79: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10dd7f: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10dd82: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10dd87: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10dd8d: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10dd8f: 74 0d je 10dd9e <_Thread_Ready+0x9a> <== NOT EXECUTED 10dd91: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10dd95: 74 07 je 10dd9e <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10dd97: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10dd9e: 53 push %ebx <== NOT EXECUTED 10dd9f: 9d popf <== NOT EXECUTED } 10dda0: 5b pop %ebx <== NOT EXECUTED 10dda1: c9 leave <== NOT EXECUTED 10dda2: c3 ret <== NOT EXECUTED 0010e87c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10e87c: 55 push %ebp <== NOT EXECUTED 10e87d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e87f: 53 push %ebx <== NOT EXECUTED 10e880: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e883: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 10e886: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10e88d: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10e894: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 10e89a: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10e89d: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10e8a3: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10e8a6: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 10e8ac: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10e8b2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e8b5: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10e8bb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e8be: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10e8c4: 53 push %ebx <== NOT EXECUTED 10e8c5: e8 c6 d4 ff ff call 10bd90 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10e8ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e8cd: 84 c0 test %al,%al <== NOT EXECUTED 10e8cf: 75 15 jne 10e8e6 <_Thread_Reset+0x6a> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10e8d1: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10e8d5: 75 0f jne 10e8e6 <_Thread_Reset+0x6a> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e8d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e8da: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10e8dd: 50 push %eax <== NOT EXECUTED 10e8de: e8 ed dd ff ff call 10c6d0 <_Watchdog_Remove> <== NOT EXECUTED 10e8e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 10e8e6: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 10e8ec: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10e8ef: 74 12 je 10e903 <_Thread_Reset+0x87> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 10e8f1: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10e8f4: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10e8f7: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 10e8fa: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e8fd: c9 leave <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10e8fe: e9 69 d6 ff ff jmp 10bf6c <_Thread_Set_priority> <== NOT EXECUTED } } 10e903: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e906: c9 leave <== NOT EXECUTED 10e907: c3 ret <== NOT EXECUTED 0010dda4 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10dda4: 55 push %ebp <== NOT EXECUTED 10dda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dda7: 56 push %esi <== NOT EXECUTED 10dda8: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10dda9: 8b 0d c0 ca 11 00 mov 0x11cac0,%ecx <== NOT EXECUTED ready = executing->ready; 10ddaf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ddb5: 9c pushf <== NOT EXECUTED 10ddb6: fa cli <== NOT EXECUTED 10ddb7: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10ddb8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ddba: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10ddbd: 75 04 jne 10ddc3 <_Thread_Reset_timeslice+0x1f> <== NOT EXECUTED _ISR_Enable( level ); 10ddbf: 56 push %esi <== NOT EXECUTED 10ddc0: 9d popf <== NOT EXECUTED 10ddc1: eb 35 jmp 10ddf8 <_Thread_Reset_timeslice+0x54> <== NOT EXECUTED 10ddc3: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10ddc5: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ddc8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10ddcb: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ddcd: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10ddd0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ddd2: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ddd5: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10ddd8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10ddda: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10dddd: 56 push %esi <== NOT EXECUTED 10ddde: 9d popf <== NOT EXECUTED 10dddf: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10dde0: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10dde6: 75 07 jne 10ddef <_Thread_Reset_timeslice+0x4b> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10dde8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ddea: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10ddef: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10ddf6: 56 push %esi <== NOT EXECUTED 10ddf7: 9d popf <== NOT EXECUTED } 10ddf8: 5b pop %ebx <== NOT EXECUTED 10ddf9: 5e pop %esi <== NOT EXECUTED 10ddfa: c9 leave <== NOT EXECUTED 10ddfb: c3 ret <== NOT EXECUTED 0010bee4 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10bee4: 55 push %ebp <== NOT EXECUTED 10bee5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bee7: 53 push %ebx <== NOT EXECUTED 10bee8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10beeb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10beee: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bef0: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10bef4: 75 70 jne 10bf66 <_Thread_Restart+0x82> <== NOT EXECUTED _Thread_Set_transient( the_thread ); 10bef6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bef9: 53 push %ebx <== NOT EXECUTED 10befa: e8 a1 01 00 00 call 10c0a0 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10beff: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bf02: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bf05: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bf08: 53 push %ebx <== NOT EXECUTED 10bf09: e8 6e 29 00 00 call 10e87c <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10bf0e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf11: e8 62 26 00 00 call 10e578 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10bf16: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf19: e8 be 28 00 00 call 10e7dc <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10bf1e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf21: e8 ee 05 00 00 call 10c514 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10bf26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bf29: b0 01 mov $0x1,%al <== NOT EXECUTED 10bf2b: 3b 1d 2c fb 11 00 cmp 0x11fb2c,%ebx <== NOT EXECUTED 10bf31: 75 33 jne 10bf66 <_Thread_Restart+0x82> <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10bf33: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10bf3a: 74 12 je 10bf4e <_Thread_Restart+0x6a> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10bf3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf3f: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10bf45: 50 push %eax <== NOT EXECUTED 10bf46: e8 43 09 00 00 call 10c88e <_CPU_Context_restore_fp> <== NOT EXECUTED 10bf4b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10bf4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf51: a1 2c fb 11 00 mov 0x11fb2c,%eax <== NOT EXECUTED 10bf56: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10bf5b: 50 push %eax <== NOT EXECUTED 10bf5c: e8 1c 09 00 00 call 10c87d <_CPU_Context_restore> <== NOT EXECUTED 10bf61: b0 01 mov $0x1,%al <== NOT EXECUTED 10bf63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10bf66: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bf69: c9 leave <== NOT EXECUTED 10bf6a: c3 ret <== NOT EXECUTED 0010c8f4 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10c8f4: 55 push %ebp <== NOT EXECUTED 10c8f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8f7: 53 push %ebx <== NOT EXECUTED 10c8f8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8fb: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10c8fe: 9c pushf <== NOT EXECUTED 10c8ff: fa cli <== NOT EXECUTED 10c900: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10c901: 84 c0 test %al,%al <== NOT EXECUTED 10c903: 74 09 je 10c90e <_Thread_Resume+0x1a> <== NOT EXECUTED the_thread->suspend_count = 0; 10c905: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) <== NOT EXECUTED 10c90c: eb 03 jmp 10c911 <_Thread_Resume+0x1d> <== NOT EXECUTED else the_thread->suspend_count--; 10c90e: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10c911: 83 79 70 00 cmpl $0x0,0x70(%ecx) <== NOT EXECUTED 10c915: 74 04 je 10c91b <_Thread_Resume+0x27> <== NOT EXECUTED _ISR_Enable( level ); 10c917: 53 push %ebx <== NOT EXECUTED 10c918: 9d popf <== NOT EXECUTED 10c919: eb 77 jmp 10c992 <_Thread_Resume+0x9e> <== NOT EXECUTED return; } current_state = the_thread->current_state; 10c91b: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10c91e: a8 02 test $0x2,%al <== NOT EXECUTED 10c920: 74 6e je 10c990 <_Thread_Resume+0x9c> <== 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( 10c922: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED current_state = 10c925: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 10c928: 85 c0 test %eax,%eax <== NOT EXECUTED 10c92a: 75 64 jne 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10c92c: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10c932: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10c939: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10c93c: 66 a1 70 84 12 00 mov 0x128470,%ax <== NOT EXECUTED 10c942: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10c948: 66 a3 70 84 12 00 mov %ax,0x128470 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10c94e: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10c954: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10c957: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10c959: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10c95c: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10c95f: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10c961: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10c964: 53 push %ebx <== NOT EXECUTED 10c965: 9d popf <== NOT EXECUTED 10c966: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10c967: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10c96a: a1 48 84 12 00 mov 0x128448,%eax <== NOT EXECUTED 10c96f: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c972: 73 1c jae 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED _Thread_Heir = the_thread; 10c974: 89 0d 48 84 12 00 mov %ecx,0x128448 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10c97a: a1 7c 84 12 00 mov 0x12847c,%eax <== NOT EXECUTED 10c97f: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10c983: 75 04 jne 10c989 <_Thread_Resume+0x95> <== NOT EXECUTED 10c985: 85 d2 test %edx,%edx <== NOT EXECUTED 10c987: 75 07 jne 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10c989: c6 05 8c 84 12 00 01 movb $0x1,0x12848c <== NOT EXECUTED } } } _ISR_Enable( level ); 10c990: 53 push %ebx <== NOT EXECUTED 10c991: 9d popf <== NOT EXECUTED } 10c992: 5b pop %ebx <== NOT EXECUTED 10c993: c9 leave <== NOT EXECUTED 10c994: c3 ret <== NOT EXECUTED 0010b548 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10b548: 55 push %ebp <== NOT EXECUTED 10b549: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b54b: 56 push %esi <== NOT EXECUTED 10b54c: 53 push %ebx <== NOT EXECUTED 10b54d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b550: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED the_thread->current_priority = new_priority; 10b553: 89 5a 14 mov %ebx,0x14(%edx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10b556: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 10b559: 03 05 c8 c9 11 00 add 0x11c9c8,%eax <== NOT EXECUTED 10b55f: 89 82 8c 00 00 00 mov %eax,0x8c(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] source is a user specified integer which may be used to * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10b565: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10b567: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10b56a: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10b56d: 8d 84 09 2c cb 11 00 lea 0x11cb2c(%ecx,%ecx,1),%eax <== NOT EXECUTED 10b574: 89 82 90 00 00 00 mov %eax,0x90(%edx) <== NOT EXECUTED bool do_dump ); 10b57a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b57f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b581: d3 e6 shl %cl,%esi <== NOT EXECUTED 10b583: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10b585: 66 89 b2 94 00 00 00 mov %si,0x94(%edx) <== NOT EXECUTED * This routine walks the heap and tots up the free and allocated 10b58c: f7 d1 not %ecx <== NOT EXECUTED 10b58e: 66 89 8a 98 00 00 00 mov %cx,0x98(%edx) <== NOT EXECUTED * sizes. * 10b595: 83 e3 0f and $0xf,%ebx <== NOT EXECUTED 10b598: 88 d9 mov %bl,%cl <== NOT EXECUTED 10b59a: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10b59c: 66 89 82 96 00 00 00 mov %ax,0x96(%edx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10b5a3: f7 d0 not %eax <== NOT EXECUTED 10b5a5: 66 89 82 9a 00 00 00 mov %ax,0x9a(%edx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10b5ac: 5b pop %ebx <== NOT EXECUTED 10b5ad: 5e pop %esi <== NOT EXECUTED 10b5ae: c9 leave <== NOT EXECUTED 10b5af: c3 ret <== NOT EXECUTED 0010b5b0 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10b5b0: 55 push %ebp <== NOT EXECUTED 10b5b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5b3: 56 push %esi <== NOT EXECUTED 10b5b4: 53 push %ebx <== NOT EXECUTED 10b5b5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b5b8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10b5bb: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10b5c1: 9c pushf <== NOT EXECUTED 10b5c2: fa cli <== NOT EXECUTED 10b5c3: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10b5c4: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 10b5c7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b5c9: 74 0c je 10b5d7 <_Thread_Set_state+0x27> <== NOT EXECUTED the_thread->current_state = 10b5cb: 09 c8 or %ecx,%eax <== NOT EXECUTED 10b5cd: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10b5d0: 56 push %esi <== NOT EXECUTED 10b5d1: 9d popf <== NOT EXECUTED 10b5d2: e9 a0 00 00 00 jmp 10b677 <_Thread_Set_state+0xc7> <== NOT EXECUTED return; } the_thread->current_state = state; 10b5d7: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b5da: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10b5dc: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10b5df: 75 39 jne 10b61a <_Thread_Set_state+0x6a> <== NOT EXECUTED 10b5e1: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b5e4: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b5e6: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b5ed: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10b5f0: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b5f6: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b5fd: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b600: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b604: 75 1e jne 10b624 <_Thread_Set_state+0x74> <== NOT EXECUTED * to be resized 10b606: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10b60c: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b612: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED 10b618: eb 0a jmp 10b624 <_Thread_Set_state+0x74> <== NOT EXECUTED 10b61a: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b61c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b61f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b622: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10b624: 56 push %esi <== NOT EXECUTED 10b625: 9d popf <== NOT EXECUTED 10b626: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10b627: 3b 1d 8c ca 11 00 cmp 0x11ca8c,%ebx <== NOT EXECUTED 10b62d: 75 37 jne 10b666 <_Thread_Set_state+0xb6> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10b62f: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10b636: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b638: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b63a: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10b63e: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10b641: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10b648: 00 <== NOT EXECUTED 10b649: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10b64d: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10b650: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10b653: 01 d0 add %edx,%eax <== NOT EXECUTED 10b655: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b658: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10b65e: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b661: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10b666: 3b 1d c0 ca 11 00 cmp 0x11cac0,%ebx <== NOT EXECUTED 10b66c: 75 07 jne 10b675 <_Thread_Set_state+0xc5> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b66e: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10b675: 56 push %esi <== NOT EXECUTED 10b676: 9d popf <== NOT EXECUTED } 10b677: 5b pop %ebx <== NOT EXECUTED 10b678: 5e pop %esi <== NOT EXECUTED 10b679: c9 leave <== NOT EXECUTED 10b67a: c3 ret <== NOT EXECUTED 0010b67c <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10b67c: 55 push %ebp <== NOT EXECUTED 10b67d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b67f: 56 push %esi <== NOT EXECUTED 10b680: 53 push %ebx <== NOT EXECUTED 10b681: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10b684: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10b68a: 9c pushf <== NOT EXECUTED 10b68b: fa cli <== NOT EXECUTED 10b68c: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10b68d: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10b690: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b692: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10b695: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10b698: 85 d2 test %edx,%edx <== NOT EXECUTED 10b69a: 75 4a jne 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b69c: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10b69e: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10b6a1: 75 39 jne 10b6dc <_Thread_Set_transient+0x60> <== NOT EXECUTED 10b6a3: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b6a6: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b6a8: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b6af: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10b6b2: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b6b8: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b6bf: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b6c2: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b6c6: 75 1e jne 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED * to be resized 10b6c8: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10b6ce: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b6d4: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED 10b6da: eb 0a jmp 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED 10b6dc: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b6de: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b6e1: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b6e4: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10b6e6: 56 push %esi <== NOT EXECUTED 10b6e7: 9d popf <== NOT EXECUTED } 10b6e8: 5b pop %ebx <== NOT EXECUTED 10b6e9: 5e pop %esi <== NOT EXECUTED 10b6ea: c9 leave <== NOT EXECUTED 10b6eb: c3 ret <== NOT EXECUTED 0010b6ec <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10b6ec: 55 push %ebp <== NOT EXECUTED 10b6ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6ef: 53 push %ebx <== NOT EXECUTED 10b6f0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b6f3: a1 80 86 11 00 mov 0x118680,%eax <== NOT EXECUTED 10b6f8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b6fb: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b6fd: 73 02 jae 10b701 <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10b6ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( _Configuration_Table->stack_allocate_hook ) { 10b701: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b706: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10b709: 85 c0 test %eax,%eax <== NOT EXECUTED 10b70b: 74 08 je 10b715 <_Thread_Stack_Allocate+0x29> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10b70d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b710: 53 push %ebx <== NOT EXECUTED 10b711: ff d0 call *%eax <== NOT EXECUTED 10b713: eb 09 jmp 10b71e <_Thread_Stack_Allocate+0x32> <== NOT EXECUTED * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10b715: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b718: 53 push %ebx <== NOT EXECUTED 10b719: e8 3f 06 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10b71e: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b720: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( !stack_addr ) 10b723: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b725: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b727: 0f 95 c0 setne %al <== NOT EXECUTED 10b72a: f7 d8 neg %eax <== NOT EXECUTED 10b72c: 21 d8 and %ebx,%eax <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10b72e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b731: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) <== NOT EXECUTED return the_stack_size; } 10b737: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b73a: c9 leave <== NOT EXECUTED 10b73b: c3 ret <== NOT EXECUTED 0010b73c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10b73c: 55 push %ebp <== NOT EXECUTED 10b73d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b73f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10b742: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10b749: 74 21 je 10b76c <_Thread_Stack_Free+0x30> <== NOT EXECUTED * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) 10b74b: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b750: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10b753: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b755: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10b75b: 74 06 je 10b763 <_Thread_Stack_Free+0x27> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10b75d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10b760: 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)( 10b761: ff e1 jmp *%ecx <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b763: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10b766: c9 leave <== NOT EXECUTED if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b767: e9 dc 05 00 00 jmp 10bd48 <_Workspace_Free> <== NOT EXECUTED } 10b76c: c9 leave <== NOT EXECUTED 10b76d: c3 ret <== NOT EXECUTED 0010b7c8 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10b7c8: 55 push %ebp <== NOT EXECUTED 10b7c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7cb: 53 push %ebx <== NOT EXECUTED 10b7cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b7cf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10b7d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b7d4: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10b7d8: 74 42 je 10b81c <_Thread_Start+0x54> <== NOT EXECUTED the_thread->Start.entry_point = (Thread_Entry) entry_point; 10b7da: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b7dd: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10b7e3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b7e6: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10b7ec: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b7ef: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10b7f5: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10b7f8: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10b7fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b801: 53 push %ebx <== NOT EXECUTED 10b802: e8 99 22 00 00 call 10daa0 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10b807: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b80a: e8 f5 24 00 00 call 10dd04 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10b80f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b812: e8 d9 02 00 00 call 10baf0 <_User_extensions_Thread_start> <== NOT EXECUTED 10b817: b0 01 mov $0x1,%al <== NOT EXECUTED 10b819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10b81c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b81f: c9 leave <== NOT EXECUTED 10b820: c3 ret <== NOT EXECUTED 0010b770 <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10b770: 55 push %ebp <== NOT EXECUTED 10b771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b773: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10b776: c7 05 a0 cb 11 00 03 movl $0x3,0x11cba0 <== NOT EXECUTED 10b77d: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10b780: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10b787: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10b78c: a3 c0 ca 11 00 mov %eax,0x11cac0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) /* * don't need to worry about saving BSP's floating point state */ if ( _Thread_Heir->fp_context != NULL ) 10b791: 83 b8 ec 00 00 00 00 cmpl $0x0,0xec(%eax) <== NOT EXECUTED 10b798: 74 11 je 10b7ab <_Thread_Start_multitasking+0x3b> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10b79a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b79d: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10b7a2: 50 push %eax <== NOT EXECUTED 10b7a3: e8 86 06 00 00 call 10be2e <_CPU_Context_restore_fp> <== NOT EXECUTED 10b7a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10b7ab: 50 push %eax <== NOT EXECUTED 10b7ac: 50 push %eax <== NOT EXECUTED 10b7ad: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10b7b2: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10b7b7: 50 push %eax <== NOT EXECUTED 10b7b8: 68 e8 c9 11 00 push $0x11c9e8 <== NOT EXECUTED 10b7bd: e8 2e 06 00 00 call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED 10b7c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b7c5: c9 leave <== NOT EXECUTED 10b7c6: c3 ret <== NOT EXECUTED 0010cc74 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10cc74: 55 push %ebp <== NOT EXECUTED 10cc75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc77: 56 push %esi <== NOT EXECUTED 10cc78: 53 push %ebx <== NOT EXECUTED 10cc79: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cc7c: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cc82: 9c pushf <== NOT EXECUTED 10cc83: fa cli <== NOT EXECUTED 10cc84: 5e pop %esi <== NOT EXECUTED the_thread->suspend_count++; 10cc85: ff 43 70 incl 0x70(%ebx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cc88: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cc8b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc8d: 74 0d je 10cc9c <_Thread_Suspend+0x28> <== NOT EXECUTED the_thread->current_state = 10cc8f: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10cc92: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10cc95: 56 push %esi <== NOT EXECUTED 10cc96: 9d popf <== NOT EXECUTED 10cc97: e9 a4 00 00 00 jmp 10cd40 <_Thread_Suspend+0xcc> <== NOT EXECUTED return; } the_thread->current_state = STATES_SUSPENDED; 10cc9c: c7 43 10 02 00 00 00 movl $0x2,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cca3: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cca5: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cca8: 75 39 jne 10cce3 <_Thread_Suspend+0x6f> <== NOT EXECUTED 10ccaa: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10ccad: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ccaf: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10ccb6: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10ccb9: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10ccbf: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10ccc6: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10ccc9: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cccd: 75 1e jne 10cced <_Thread_Suspend+0x79> <== NOT EXECUTED * to be resized 10cccf: 66 a1 70 84 12 00 mov 0x128470,%ax <== NOT EXECUTED 10ccd5: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10ccdb: 66 a3 70 84 12 00 mov %ax,0x128470 <== NOT EXECUTED 10cce1: eb 0a jmp 10cced <_Thread_Suspend+0x79> <== NOT EXECUTED 10cce3: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cce5: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cce8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cceb: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10cced: 56 push %esi <== NOT EXECUTED 10ccee: 9d popf <== NOT EXECUTED 10ccef: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10ccf0: 3b 1d 48 84 12 00 cmp 0x128448,%ebx <== NOT EXECUTED 10ccf6: 75 37 jne 10cd2f <_Thread_Suspend+0xbb> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10ccf8: 66 8b 0d 70 84 12 00 mov 0x128470,%cx <== NOT EXECUTED 10ccff: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd01: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd03: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10cd07: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10cd0a: 66 8b 8c 00 e8 84 12 mov 0x1284e8(%eax,%eax,1),%cx <== NOT EXECUTED 10cd11: 00 <== NOT EXECUTED 10cd12: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10cd16: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10cd19: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10cd1c: 01 d0 add %edx,%eax <== NOT EXECUTED 10cd1e: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10cd21: 8b 15 84 83 12 00 mov 0x128384,%edx <== NOT EXECUTED 10cd27: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10cd2a: a3 48 84 12 00 mov %eax,0x128448 <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cd2f: 3b 1d 7c 84 12 00 cmp 0x12847c,%ebx <== NOT EXECUTED 10cd35: 75 07 jne 10cd3e <_Thread_Suspend+0xca> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10cd37: c6 05 8c 84 12 00 01 movb $0x1,0x12848c <== NOT EXECUTED _ISR_Enable( level ); 10cd3e: 56 push %esi <== NOT EXECUTED 10cd3f: 9d popf <== NOT EXECUTED } 10cd40: 5b pop %ebx <== NOT EXECUTED 10cd41: 5e pop %esi <== NOT EXECUTED 10cd42: c9 leave <== NOT EXECUTED 10cd43: c3 ret <== NOT EXECUTED 0010b824 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10b824: 55 push %ebp <== NOT EXECUTED 10b825: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b827: 53 push %ebx <== NOT EXECUTED 10b828: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10b82b: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10b831: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10b835: 74 4c je 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10b837: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10b83b: 75 46 jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10b83d: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10b840: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b843: 72 3e jb 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b845: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b848: 76 07 jbe 10b851 <_Thread_Tickle_timeslice+0x2d> <== NOT EXECUTED 10b84a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b84d: 75 34 jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b84f: eb 1a jmp 10b86b <_Thread_Tickle_timeslice+0x47> <== 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 ) { 10b851: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b854: 48 dec %eax <== NOT EXECUTED 10b855: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b858: 85 c0 test %eax,%eax <== NOT EXECUTED 10b85a: 7f 27 jg 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED _Thread_Reset_timeslice(); 10b85c: e8 43 25 00 00 call 10dda4 <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b861: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10b866: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b869: eb 18 jmp 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10b86b: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b86e: 48 dec %eax <== NOT EXECUTED 10b86f: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b872: 85 c0 test %eax,%eax <== NOT EXECUTED 10b874: 75 0d jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10b876: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b879: 53 push %ebx <== NOT EXECUTED 10b87a: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10b880: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } 10b883: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b886: c9 leave <== NOT EXECUTED 10b887: c3 ret <== NOT EXECUTED 0010b888 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10b888: 55 push %ebp <== NOT EXECUTED 10b889: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b88b: 56 push %esi <== NOT EXECUTED 10b88c: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10b88d: 8b 0d c0 ca 11 00 mov 0x11cac0,%ecx <== NOT EXECUTED ready = executing->ready; 10b893: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10b899: 9c pushf <== NOT EXECUTED 10b89a: fa cli <== NOT EXECUTED 10b89b: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10b89c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b89e: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10b8a1: 74 2e je 10b8d1 <_Thread_Yield_processor+0x49> <== NOT EXECUTED 10b8a3: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10b8a5: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10b8a8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b8ab: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10b8ad: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10b8b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b8b2: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10b8b5: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10b8b8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10b8ba: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10b8bd: 56 push %esi <== NOT EXECUTED 10b8be: 9d popf <== NOT EXECUTED 10b8bf: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10b8c0: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10b8c6: 75 11 jne 10b8d9 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10b8c8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b8ca: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED 10b8cf: eb 08 jmp 10b8d9 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10b8d1: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10b8d7: 74 07 je 10b8e0 <_Thread_Yield_processor+0x58> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b8d9: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10b8e0: 56 push %esi <== NOT EXECUTED 10b8e1: 9d popf <== NOT EXECUTED } 10b8e2: 5b pop %ebx <== NOT EXECUTED 10b8e3: 5e pop %esi <== NOT EXECUTED 10b8e4: c9 leave <== NOT EXECUTED 10b8e5: c3 ret <== NOT EXECUTED 0010a8d4 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10a8d4: 55 push %ebp <== NOT EXECUTED 10a8d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8d7: 53 push %ebx <== NOT EXECUTED 10a8d8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a8db: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a8de: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 10a8e1: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED /* * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 10a8e8: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10a8ec: 75 1a jne 10a908 <_Thread_blocking_operation_Cancel+0x34> <== 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 */ 10a8ee: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10a8f5: 50 push %eax <== NOT EXECUTED 10a8f6: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10a8f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8fa: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10a8fd: 50 push %eax <== NOT EXECUTED 10a8fe: e8 71 13 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10a903: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a906: eb 02 jmp 10a90a <_Thread_blocking_operation_Cancel+0x36> <== NOT EXECUTED } else _ISR_Enable( level ); 10a908: 50 push %eax <== NOT EXECUTED 10a909: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a90a: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10a911: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10a914: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a917: c9 leave <== NOT EXECUTED 10a918: e9 23 01 00 00 jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 0010b0f8 <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 53 push %ebx <== NOT EXECUTED 10b0fc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0ff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *(*dequeue_p)( Thread_queue_Control * ); Thread_Control *the_thread; ISR_Level level; Thread_blocking_operation_States sync_state; if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10b102: b8 44 b1 10 00 mov $0x10b144,%eax <== NOT EXECUTED 10b107: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b10b: 74 05 je 10b112 <_Thread_queue_Dequeue+0x1a> <== NOT EXECUTED 10b10d: b8 28 db 10 00 mov $0x10db28,%eax <== NOT EXECUTED dequeue_p = _Thread_queue_Dequeue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ dequeue_p = _Thread_queue_Dequeue_fifo; the_thread = (*dequeue_p)( the_thread_queue ); 10b112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b115: 53 push %ebx <== NOT EXECUTED 10b116: ff d0 call *%eax <== NOT EXECUTED 10b118: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10b11a: 9c pushf <== NOT EXECUTED 10b11b: fa cli <== NOT EXECUTED 10b11c: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10b11d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b120: 85 c0 test %eax,%eax <== NOT EXECUTED 10b122: 75 16 jne 10b13a <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED sync_state = the_thread_queue->sync_state; if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b124: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10b127: 48 dec %eax <== NOT EXECUTED 10b128: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b12b: 77 0d ja 10b13a <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b12d: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10b134: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED } } _ISR_Enable( level ); 10b13a: 51 push %ecx <== NOT EXECUTED 10b13b: 9d popf <== NOT EXECUTED return the_thread; } 10b13c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b13e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b141: c9 leave <== NOT EXECUTED 10b142: c3 ret <== NOT EXECUTED 0010db28 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10db28: 55 push %ebp <== NOT EXECUTED 10db29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db2b: 56 push %esi <== NOT EXECUTED 10db2c: 53 push %ebx <== NOT EXECUTED 10db2d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10db30: 9c pushf <== NOT EXECUTED 10db31: fa cli <== NOT EXECUTED 10db32: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10db33: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10db35: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10db38: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10db3a: 74 43 je 10db7f <_Thread_queue_Dequeue_fifo+0x57> <== NOT EXECUTED 10db3c: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10db3e: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10db40: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10db43: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10db45: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10db4c: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10db50: 74 06 je 10db58 <_Thread_queue_Dequeue_fifo+0x30> <== NOT EXECUTED _ISR_Enable( level ); 10db52: 56 push %esi <== NOT EXECUTED 10db53: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10db54: 51 push %ecx <== NOT EXECUTED 10db55: 51 push %ecx <== NOT EXECUTED 10db56: eb 17 jmp 10db6f <_Thread_queue_Dequeue_fifo+0x47> <== 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 */ 10db58: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10db5f: 56 push %esi <== NOT EXECUTED 10db60: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10db61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10db64: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10db67: 50 push %eax <== NOT EXECUTED 10db68: e8 07 e1 ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10db6d: 58 pop %eax <== NOT EXECUTED 10db6e: 5a pop %edx <== NOT EXECUTED 10db6f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10db74: 53 push %ebx <== NOT EXECUTED 10db75: e8 c6 ce ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10db7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10db7d: eb 04 jmp 10db83 <_Thread_queue_Dequeue_fifo+0x5b> <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10db7f: 56 push %esi <== NOT EXECUTED 10db80: 9d popf <== NOT EXECUTED 10db81: 31 db xor %ebx,%ebx <== NOT EXECUTED return NULL; } 10db83: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10db85: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10db88: 5b pop %ebx <== NOT EXECUTED 10db89: 5e pop %esi <== NOT EXECUTED 10db8a: c9 leave <== NOT EXECUTED 10db8b: c3 ret <== NOT EXECUTED 0010b144 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10b144: 55 push %ebp <== NOT EXECUTED 10b145: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b147: 57 push %edi <== NOT EXECUTED 10b148: 56 push %esi <== NOT EXECUTED 10b149: 53 push %ebx <== NOT EXECUTED 10b14a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b14d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10b150: 9c pushf <== NOT EXECUTED 10b151: fa cli <== NOT EXECUTED 10b152: 8f 45 e8 popl -0x18(%ebp) <== NOT EXECUTED 10b155: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b157: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10b159: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10b15c: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 10b15f: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 10b163: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b165: 74 1b je 10b182 <_Thread_queue_Dequeue_priority+0x3e> <== NOT EXECUTED the_thread = (Thread_Control *) 10b167: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10b16a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10b171: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10b174: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10b176: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10b179: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10b17c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b17e: 75 18 jne 10b198 <_Thread_queue_Dequeue_priority+0x54> <== NOT EXECUTED 10b180: eb 49 jmp 10b1cb <_Thread_queue_Dequeue_priority+0x87> <== NOT EXECUTED Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10b182: 42 inc %edx <== NOT EXECUTED 10b183: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10b186: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10b189: 75 ce jne 10b159 <_Thread_queue_Dequeue_priority+0x15> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10b18b: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b18e: 9d popf <== NOT EXECUTED 10b18f: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 10b196: eb 6d jmp 10b205 <_Thread_queue_Dequeue_priority+0xc1> <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = the_thread->Wait.Block2n.last; 10b198: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b19b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10b19e: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10b1a0: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10b1a2: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10b1a5: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10b1a7: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10b1aa: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b1ad: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b1b0: 74 1e je 10b1d0 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10b1b2: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10b1b5: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10b1b8: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10b1bb: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b1be: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10b1c1: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10b1c4: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1c7: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b1c9: eb 05 jmp 10b1d0 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED } } else { previous_node->next = next_node; 10b1cb: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10b1cd: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b1d0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10b1d4: 74 08 je 10b1de <_Thread_queue_Dequeue_priority+0x9a> <== NOT EXECUTED _ISR_Enable( level ); 10b1d6: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b1d9: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b1da: 51 push %ecx <== NOT EXECUTED 10b1db: 51 push %ecx <== NOT EXECUTED 10b1dc: eb 19 jmp 10b1f7 <_Thread_queue_Dequeue_priority+0xb3> <== 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 */ 10b1de: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10b1e5: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b1e8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10b1e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b1ec: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b1ef: 50 push %eax <== NOT EXECUTED 10b1f0: e8 7f 0a 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b1f5: 58 pop %eax <== NOT EXECUTED 10b1f6: 5a pop %edx <== NOT EXECUTED 10b1f7: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10b1fc: 53 push %ebx <== NOT EXECUTED 10b1fd: e8 3e f8 ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10b202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10b205: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b208: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b20b: 5b pop %ebx <== NOT EXECUTED 10b20c: 5e pop %esi <== NOT EXECUTED 10b20d: 5f pop %edi <== NOT EXECUTED 10b20e: c9 leave <== NOT EXECUTED 10b20f: c3 ret <== NOT EXECUTED 0010db8c <_Thread_queue_Enqueue_fifo>: Thread_blocking_operation_States _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10db8c: 55 push %ebp <== NOT EXECUTED 10db8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db8f: 56 push %esi <== NOT EXECUTED 10db90: 53 push %ebx <== NOT EXECUTED 10db91: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10db94: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10db97: 9c pushf <== NOT EXECUTED 10db98: fa cli <== NOT EXECUTED 10db99: 5b pop %ebx <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10db9a: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10db9d: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10dba4: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10dba7: 75 17 jne 10dbc0 <_Thread_queue_Enqueue_fifo+0x34> <== NOT EXECUTED 10dba9: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10dbac: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10dbae: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10dbb1: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED 10dbb4: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10dbb6: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 10dbb9: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10dbbc: 53 push %ebx <== NOT EXECUTED 10dbbd: 9d popf <== NOT EXECUTED 10dbbe: eb 05 jmp 10dbc5 <_Thread_queue_Enqueue_fifo+0x39> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10dbc0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dbc3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return sync_state; } 10dbc5: 89 f0 mov %esi,%eax <== NOT EXECUTED 10dbc7: 5b pop %ebx <== NOT EXECUTED 10dbc8: 5e pop %esi <== NOT EXECUTED 10dbc9: c9 leave <== NOT EXECUTED 10dbca: c3 ret <== NOT EXECUTED 0010b29c <_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 ) { 10b29c: 55 push %ebp <== NOT EXECUTED 10b29d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b29f: 57 push %edi <== NOT EXECUTED 10b2a0: 56 push %esi <== NOT EXECUTED 10b2a1: 53 push %ebx <== NOT EXECUTED 10b2a2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b2a5: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b2a8: 8d 41 3c lea 0x3c(%ecx),%eax <== NOT EXECUTED 10b2ab: 89 41 38 mov %eax,0x38(%ecx) <== NOT EXECUTED 10b2ae: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED 10b2b5: 8d 41 38 lea 0x38(%ecx),%eax <== NOT EXECUTED 10b2b8: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10b2bb: 8b 79 14 mov 0x14(%ecx),%edi <== NOT EXECUTED extern "C" { #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. 10b2be: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b2c0: c1 e8 06 shr $0x6,%eax <== NOT EXECUTED header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10b2c3: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b2c6: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b2c9: 01 c3 add %eax,%ebx <== NOT EXECUTED block_state = the_thread_queue->state; 10b2cb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b2ce: 8b 52 38 mov 0x38(%edx),%edx <== NOT EXECUTED 10b2d1: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10b2d4: f7 c7 20 00 00 00 test $0x20,%edi <== NOT EXECUTED 10b2da: 75 77 jne 10b353 <_Thread_queue_Enqueue_priority+0xb7> <== 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 10b2dc: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 10b2df: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10b2e2: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10b2e5: 9c pushf <== NOT EXECUTED 10b2e6: fa cli <== NOT EXECUTED 10b2e7: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10b2e8: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10b2eb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b2ee: 8b 14 18 mov (%eax,%ebx,1),%edx <== NOT EXECUTED 10b2f1: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) <== NOT EXECUTED 10b2f8: eb 1b jmp 10b315 <_Thread_queue_Enqueue_priority+0x79> <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b2fa: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED 10b2fd: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED if ( priority <= search_priority ) 10b300: 39 df cmp %ebx,%edi <== NOT EXECUTED 10b302: 76 16 jbe 10b31a <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10b304: 56 push %esi <== NOT EXECUTED 10b305: 9d popf <== NOT EXECUTED 10b306: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b307: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b30a: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b30d: 75 04 jne 10b313 <_Thread_queue_Enqueue_priority+0x77> <== NOT EXECUTED _ISR_Enable( level ); 10b30f: 56 push %esi <== NOT EXECUTED 10b310: 9d popf <== NOT EXECUTED 10b311: eb d2 jmp 10b2e5 <_Thread_queue_Enqueue_priority+0x49> <== NOT EXECUTED goto restart_forward_search; } search_thread = 10b313: 8b 12 mov (%edx),%edx <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10b315: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10b318: 75 e0 jne 10b2fa <_Thread_queue_Enqueue_priority+0x5e> <== NOT EXECUTED 10b31a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b31d: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10b31f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b322: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b326: 0f 85 b4 00 00 00 jne 10b3e0 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b32c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b333: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b336: 0f 84 87 00 00 00 je 10b3c3 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10b33c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b33f: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b341: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b344: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10b346: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b349: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b34c: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b34f: 56 push %esi <== NOT EXECUTED 10b350: 9d popf <== NOT EXECUTED 10b351: eb 69 jmp 10b3bc <_Thread_queue_Enqueue_priority+0x120> <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10b353: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10b356: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10b359: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10b360: 40 inc %eax <== NOT EXECUTED 10b361: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10b364: 9c pushf <== NOT EXECUTED 10b365: fa cli <== NOT EXECUTED 10b366: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10b367: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b36a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b36c: eb 1c jmp 10b38a <_Thread_queue_Enqueue_priority+0xee> <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b36e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10b371: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( priority >= search_priority ) 10b374: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10b376: 73 16 jae 10b38e <_Thread_queue_Enqueue_priority+0xf2> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10b378: 56 push %esi <== NOT EXECUTED 10b379: 9d popf <== NOT EXECUTED 10b37a: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b37b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b37e: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b381: 75 04 jne 10b387 <_Thread_queue_Enqueue_priority+0xeb> <== NOT EXECUTED _ISR_Enable( level ); 10b383: 56 push %esi <== NOT EXECUTED 10b384: 9d popf <== NOT EXECUTED 10b385: eb d2 jmp 10b359 <_Thread_queue_Enqueue_priority+0xbd> <== NOT EXECUTED goto restart_reverse_search; } search_thread = (Thread_Control *) 10b387: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10b38a: 39 da cmp %ebx,%edx <== NOT EXECUTED 10b38c: 75 e0 jne 10b36e <_Thread_queue_Enqueue_priority+0xd2> <== NOT EXECUTED 10b38e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b391: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10b393: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b396: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b39a: 75 44 jne 10b3e0 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b39c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b3a3: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b3a6: 74 1b je 10b3c3 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10b3a8: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10b3aa: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = search_node; 10b3ac: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED search_node->next = the_node; 10b3af: 89 0a mov %ecx,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10b3b1: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b3b4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b3b7: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b3ba: 56 push %esi <== NOT EXECUTED 10b3bb: 9d popf <== NOT EXECUTED 10b3bc: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b3c1: eb 28 jmp 10b3eb <_Thread_queue_Enqueue_priority+0x14f> <== NOT EXECUTED 10b3c3: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b3c6: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED 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; 10b3c9: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b3cc: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b3ce: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b3d1: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10b3d3: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b3d6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b3d9: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b3dc: 53 push %ebx <== NOT EXECUTED 10b3dd: 9d popf <== NOT EXECUTED 10b3de: eb dc jmp 10b3bc <_Thread_queue_Enqueue_priority+0x120> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10b3e0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b3e3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10b3e5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b3e8: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10b3eb: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10b3ee: 5b pop %ebx <== NOT EXECUTED 10b3ef: 5e pop %esi <== NOT EXECUTED 10b3f0: 5f pop %edi <== NOT EXECUTED 10b3f1: c9 leave <== NOT EXECUTED 10b3f2: c3 ret <== NOT EXECUTED 0010b210 <_Thread_queue_Enqueue_with_handler>: void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 10b210: 55 push %ebp <== NOT EXECUTED 10b211: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b213: 57 push %edi <== NOT EXECUTED 10b214: 56 push %esi <== NOT EXECUTED 10b215: 53 push %ebx <== NOT EXECUTED 10b216: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10b219: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b21c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10b21f: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 10b225: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10b228: 53 push %ebx <== NOT EXECUTED 10b229: e8 82 03 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10b22e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b231: 85 ff test %edi,%edi <== NOT EXECUTED 10b233: 74 30 je 10b265 <_Thread_queue_Enqueue_with_handler+0x55> <== NOT EXECUTED _Watchdog_Initialize( 10b235: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10b238: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b23f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b242: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b245: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10b248: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10b24f: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b252: 57 push %edi <== NOT EXECUTED 10b253: 57 push %edi <== NOT EXECUTED 10b254: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b257: 50 push %eax <== NOT EXECUTED 10b258: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 10b25d: e8 fa 08 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 10b262: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now enqueue the thread per the discipline for this thread queue. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10b265: ba 9c b2 10 00 mov $0x10b29c,%edx <== NOT EXECUTED 10b26a: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10b26e: 74 05 je 10b275 <_Thread_queue_Enqueue_with_handler+0x65> <== NOT EXECUTED 10b270: ba 8c db 10 00 mov $0x10db8c,%edx <== NOT EXECUTED enqueue_p = _Thread_queue_Enqueue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ enqueue_p = _Thread_queue_Enqueue_fifo; sync_state = (*enqueue_p)( the_thread_queue, the_thread, &level ); 10b275: 51 push %ecx <== NOT EXECUTED 10b276: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b279: 50 push %eax <== NOT EXECUTED 10b27a: 53 push %ebx <== NOT EXECUTED 10b27b: 56 push %esi <== NOT EXECUTED 10b27c: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b27e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b281: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b284: 74 0e je 10b294 <_Thread_queue_Enqueue_with_handler+0x84> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10b286: 52 push %edx <== NOT EXECUTED 10b287: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b28a: 53 push %ebx <== NOT EXECUTED 10b28b: 50 push %eax <== NOT EXECUTED 10b28c: e8 43 f6 ff ff call 10a8d4 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10b291: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b294: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b297: 5b pop %ebx <== NOT EXECUTED 10b298: 5e pop %esi <== NOT EXECUTED 10b299: 5f pop %edi <== NOT EXECUTED 10b29a: c9 leave <== NOT EXECUTED 10b29b: c3 ret <== NOT EXECUTED 0010dbcc <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10dbcc: 55 push %ebp <== NOT EXECUTED 10dbcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbcf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbd2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dbd5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10dbd8: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10dbdc: 75 0f jne 10dbed <_Thread_queue_Extract+0x21> <== NOT EXECUTED _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 10dbde: 51 push %ecx <== NOT EXECUTED 10dbdf: 6a 00 push $0x0 <== NOT EXECUTED 10dbe1: 52 push %edx <== NOT EXECUTED 10dbe2: 50 push %eax <== NOT EXECUTED 10dbe3: e8 14 00 00 00 call 10dbfc <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10dbe8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10dbeb: c9 leave <== NOT EXECUTED 10dbec: c3 ret <== NOT EXECUTED * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10dbed: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10dbf0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10dbf3: c9 leave <== NOT EXECUTED * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10dbf4: e9 f3 09 00 00 jmp 10e5ec <_Thread_queue_Extract_fifo> <== NOT EXECUTED 0010e5ec <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e5ec: 55 push %ebp <== NOT EXECUTED 10e5ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5ef: 53 push %ebx <== NOT EXECUTED 10e5f0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10e5f3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10e5f6: 9c pushf <== NOT EXECUTED 10e5f7: fa cli <== NOT EXECUTED 10e5f8: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e5f9: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10e600: 75 07 jne 10e609 <_Thread_queue_Extract_fifo+0x1d> <== NOT EXECUTED _ISR_Enable( level ); 10e602: 51 push %ecx <== NOT EXECUTED 10e603: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10e604: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e607: c9 leave <== NOT EXECUTED 10e608: c3 ret <== NOT EXECUTED 10e609: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10e60b: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e60e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e611: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 10e613: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10e61a: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10e61e: 74 04 je 10e624 <_Thread_queue_Extract_fifo+0x38> <== NOT EXECUTED _ISR_Enable( level ); 10e620: 51 push %ecx <== NOT EXECUTED 10e621: 9d popf <== NOT EXECUTED 10e622: eb 18 jmp 10e63c <_Thread_queue_Extract_fifo+0x50> <== 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 */ 10e624: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10e62b: 51 push %ecx <== NOT EXECUTED 10e62c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e62d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e630: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10e633: 50 push %eax <== NOT EXECUTED 10e634: e8 3b d6 ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10e639: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e63c: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10e643: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10e646: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e649: c9 leave <== NOT EXECUTED 10e64a: e9 f1 c3 ff ff jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 0010dbfc <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10dbfc: 55 push %ebp <== NOT EXECUTED 10dbfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbff: 57 push %edi <== NOT EXECUTED 10dc00: 56 push %esi <== NOT EXECUTED 10dc01: 53 push %ebx <== NOT EXECUTED 10dc02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc05: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10dc08: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10dc0b: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 10dc0e: 9c pushf <== NOT EXECUTED 10dc0f: fa cli <== NOT EXECUTED 10dc10: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10dc13: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10dc1a: 75 09 jne 10dc25 <_Thread_queue_Extract_priority_helper+0x29> <== NOT EXECUTED _ISR_Enable( level ); 10dc1c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc1f: 9d popf <== NOT EXECUTED 10dc20: e9 8f 00 00 00 jmp 10dcb4 <_Thread_queue_Extract_priority_helper+0xb8> <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10dc25: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10dc27: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10dc2a: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10dc2d: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10dc30: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10dc32: 74 33 je 10dc67 <_Thread_queue_Extract_priority_helper+0x6b> <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 10dc34: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10dc37: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10dc3a: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10dc3c: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10dc3e: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10dc41: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10dc43: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10dc46: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10dc49: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10dc4c: 74 1e je 10dc6c <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10dc4e: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10dc51: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10dc54: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10dc57: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10dc5a: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10dc5d: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10dc60: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10dc63: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10dc65: eb 05 jmp 10dc6c <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED } } else { previous_node->next = next_node; 10dc67: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10dc69: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10dc6c: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10dc70: 74 06 je 10dc78 <_Thread_queue_Extract_priority_helper+0x7c> <== NOT EXECUTED _ISR_Enable( level ); 10dc72: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc75: 9d popf <== NOT EXECUTED 10dc76: eb 3c jmp 10dcb4 <_Thread_queue_Extract_priority_helper+0xb8> <== NOT EXECUTED return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10dc78: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10dc7c: 74 06 je 10dc84 <_Thread_queue_Extract_priority_helper+0x88> <== NOT EXECUTED _ISR_Enable( level ); 10dc7e: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc81: 9d popf <== NOT EXECUTED 10dc82: eb 1a jmp 10dc9e <_Thread_queue_Extract_priority_helper+0xa2> <== 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 */ 10dc84: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10dc8b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc8e: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10dc8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc92: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10dc95: 50 push %eax <== NOT EXECUTED 10dc96: e8 d9 df ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10dc9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10dc9e: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10dca5: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10dca8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcab: 5b pop %ebx <== NOT EXECUTED 10dcac: 5e pop %esi <== NOT EXECUTED 10dcad: 5f pop %edi <== NOT EXECUTED 10dcae: c9 leave <== NOT EXECUTED 10dcaf: e9 8c cd ff ff jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10dcb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcb7: 5b pop %ebx <== NOT EXECUTED 10dcb8: 5e pop %esi <== NOT EXECUTED 10dcb9: 5f pop %edi <== NOT EXECUTED 10dcba: c9 leave <== NOT EXECUTED 10dcbb: c3 ret <== NOT EXECUTED 0010b3f4 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10b3f4: 55 push %ebp <== NOT EXECUTED 10b3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b3f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3fa: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10b3fd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b3ff: f7 42 10 e0 be 03 00 testl $0x3bee0,0x10(%edx) <== NOT EXECUTED 10b406: 74 10 je 10b418 <_Thread_queue_Extract_with_proxy+0x24> <== NOT EXECUTED if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10b408: 50 push %eax <== NOT EXECUTED 10b409: 50 push %eax <== NOT EXECUTED 10b40a: 52 push %edx <== NOT EXECUTED 10b40b: ff 72 44 pushl 0x44(%edx) <== NOT EXECUTED 10b40e: e8 b9 27 00 00 call 10dbcc <_Thread_queue_Extract> <== NOT EXECUTED 10b413: b0 01 mov $0x1,%al <== NOT EXECUTED 10b415: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10b418: c9 leave <== NOT EXECUTED 10b419: c3 ret <== NOT EXECUTED 00118790 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 118790: 55 push %ebp <== NOT EXECUTED 118791: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118793: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 118796: b9 ac 87 11 00 mov $0x1187ac,%ecx <== NOT EXECUTED 11879b: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 11879f: 74 05 je 1187a6 <_Thread_queue_First+0x16> <== NOT EXECUTED 1187a1: b9 c8 90 11 00 mov $0x1190c8,%ecx <== NOT EXECUTED first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 1187a6: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1187a9: c9 leave <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 1187aa: ff e1 jmp *%ecx <== NOT EXECUTED 001190c8 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 1190c8: 55 push %ebp <== NOT EXECUTED 1190c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1190cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1190ce: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 1190d1: 8b 00 mov (%eax),%eax <== NOT EXECUTED Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1190d3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1190d5: 0f 95 c2 setne %dl <== NOT EXECUTED 1190d8: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 1190db: f7 da neg %edx <== NOT EXECUTED 1190dd: 21 d0 and %edx,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 1190df: c9 leave <== NOT EXECUTED 1190e0: c3 ret <== NOT EXECUTED 001187ac <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 1187ac: 55 push %ebp <== NOT EXECUTED 1187ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1187af: 56 push %esi <== NOT EXECUTED 1187b0: 53 push %ebx <== NOT EXECUTED 1187b1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1187b4: 31 d2 xor %edx,%edx <== NOT EXECUTED 1187b6: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1187b8: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) 1187bb: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 1187be: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 1187c2: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 1187c4: 74 04 je 1187ca <_Thread_queue_First_priority+0x1e> <== NOT EXECUTED return (Thread_Control *) 1187c6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1187c8: eb 0b jmp 1187d5 <_Thread_queue_First_priority+0x29> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 1187ca: 42 inc %edx <== NOT EXECUTED 1187cb: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 1187ce: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 1187d1: 75 e5 jne 1187b8 <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 1187d3: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 1187d5: 5b pop %ebx <== NOT EXECUTED 1187d6: 5e pop %esi <== NOT EXECUTED 1187d7: c9 leave <== NOT EXECUTED 1187d8: c3 ret <== NOT EXECUTED 0010b41c <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b41c: 55 push %ebp <== NOT EXECUTED 10b41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b41f: 56 push %esi <== NOT EXECUTED 10b420: 53 push %ebx <== NOT EXECUTED 10b421: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b424: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10b427: eb 03 jmp 10b42c <_Thread_queue_Flush+0x10> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; 10b429: 89 58 34 mov %ebx,0x34(%eax) <== NOT EXECUTED uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10b42c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b42f: 56 push %esi <== NOT EXECUTED 10b430: e8 c3 fc ff ff call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b435: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b438: 85 c0 test %eax,%eax <== NOT EXECUTED 10b43a: 75 ed jne 10b429 <_Thread_queue_Flush+0xd> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10b43c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b43f: 5b pop %ebx <== NOT EXECUTED 10b440: 5e pop %esi <== NOT EXECUTED 10b441: c9 leave <== NOT EXECUTED 10b442: c3 ret <== NOT EXECUTED 0010b444 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10b444: 55 push %ebp <== NOT EXECUTED 10b445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b447: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b44a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10b44d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b450: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10b453: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10b456: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b459: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b45c: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10b463: 48 dec %eax <== NOT EXECUTED 10b464: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b467: 75 47 jne 10b4b0 <_Thread_queue_Initialize+0x6c> <== NOT EXECUTED 10b469: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b46b: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b472: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10b475: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b478: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10b47b: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10b482: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10b485: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10b488: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10b48b: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10b48e: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10b495: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10b498: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10b49b: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10b49e: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10b4a1: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10b4a8: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10b4ab: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10b4ae: eb 0c jmp 10b4bc <_Thread_queue_Initialize+0x78> <== NOT EXECUTED 10b4b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b4b2: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b4b9: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10b4bc: c9 leave <== NOT EXECUTED 10b4bd: c3 ret <== NOT EXECUTED 0010dcbc <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10dcbc: 55 push %ebp <== NOT EXECUTED 10dcbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcbf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcc2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10dcc5: 8b 51 44 mov 0x44(%ecx),%edx <== NOT EXECUTED * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 10dcc8: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10dccb: 85 c0 test %eax,%eax <== NOT EXECUTED 10dccd: 74 1c je 10dceb <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED 10dccf: 3b 0d c0 ca 11 00 cmp 0x11cac0,%ecx <== NOT EXECUTED 10dcd5: 75 14 jne 10dceb <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10dcd7: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dcda: 74 23 je 10dcff <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10dcdc: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10dcdf: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10dce2: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) <== NOT EXECUTED 10dce9: eb 14 jmp 10dcff <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10dceb: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10dcee: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10dcf1: 50 push %eax <== NOT EXECUTED 10dcf2: 50 push %eax <== NOT EXECUTED 10dcf3: 51 push %ecx <== NOT EXECUTED 10dcf4: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10dcf7: e8 d0 fe ff ff call 10dbcc <_Thread_queue_Extract> <== NOT EXECUTED 10dcfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10dcff: c9 leave <== NOT EXECUTED 10dd00: c3 ret <== NOT EXECUTED 0010b4c0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10b4c0: 55 push %ebp <== NOT EXECUTED 10b4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4c3: 57 push %edi <== NOT EXECUTED 10b4c4: 56 push %esi <== NOT EXECUTED 10b4c5: 53 push %ebx <== NOT EXECUTED 10b4c6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b4c9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b4cc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10b4cf: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4d1: 74 36 je 10b509 <_Thread_queue_Requeue+0x49> <== NOT EXECUTED /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10b4d3: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b4d7: 75 30 jne 10b509 <_Thread_queue_Requeue+0x49> <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10b4d9: 9c pushf <== NOT EXECUTED 10b4da: fa cli <== NOT EXECUTED 10b4db: 5f pop %edi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10b4dc: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) <== NOT EXECUTED 10b4e3: 74 22 je 10b507 <_Thread_queue_Requeue+0x47> <== 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 10b4e5: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 10b4ec: 50 push %eax <== NOT EXECUTED 10b4ed: 6a 01 push $0x1 <== NOT EXECUTED 10b4ef: 56 push %esi <== NOT EXECUTED 10b4f0: 53 push %ebx <== NOT EXECUTED 10b4f1: e8 06 27 00 00 call 10dbfc <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10b4f6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b4f9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b4fc: 50 push %eax <== NOT EXECUTED 10b4fd: 56 push %esi <== NOT EXECUTED 10b4fe: 53 push %ebx <== NOT EXECUTED 10b4ff: e8 98 fd ff ff call 10b29c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10b504: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 10b507: 57 push %edi <== NOT EXECUTED 10b508: 9d popf <== NOT EXECUTED } } 10b509: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b50c: 5b pop %ebx <== NOT EXECUTED 10b50d: 5e pop %esi <== NOT EXECUTED 10b50e: 5f pop %edi <== NOT EXECUTED 10b50f: c9 leave <== NOT EXECUTED 10b510: c3 ret <== NOT EXECUTED 0010b514 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10b514: 55 push %ebp <== NOT EXECUTED 10b515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b517: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b51a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b51d: 50 push %eax <== NOT EXECUTED 10b51e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b521: e8 ba f8 ff ff call 10ade0 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b529: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b52d: 75 17 jne 10b546 <_Thread_queue_Timeout+0x32> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10b52f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b532: 50 push %eax <== NOT EXECUTED 10b533: e8 84 27 00 00 call 10dcbc <_Thread_queue_Process_timeout> <== NOT EXECUTED 10b538: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10b53d: 48 dec %eax <== NOT EXECUTED 10b53e: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10b543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10b546: c9 leave <== NOT EXECUTED 10b547: c3 ret <== NOT EXECUTED 0010d344 <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10d344: 55 push %ebp <== NOT EXECUTED 10d345: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d347: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d34a: 6a 04 push $0x4 <== NOT EXECUTED 10d34c: 6a 00 push $0x0 <== NOT EXECUTED 10d34e: 6a 3c push $0x3c <== NOT EXECUTED 10d350: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d353: 6a 02 push $0x2 <== NOT EXECUTED 10d355: 6a 02 push $0x2 <== NOT EXECUTED 10d357: 68 74 ce 11 00 push $0x11ce74 <== NOT EXECUTED 10d35c: e8 f7 d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED /* * Initialize the pointer to the Timer Server TCB to NULL indicating * that task-based timer support is not initialized. */ _Timer_Server = NULL; 10d361: c7 05 b8 ce 11 00 00 movl $0x0,0x11ceb8 <== NOT EXECUTED 10d368: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10d36b: c7 05 b4 ce 11 00 00 movl $0x0,0x11ceb4 <== NOT EXECUTED 10d372: 00 00 00 <== NOT EXECUTED 10d375: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10d378: c9 leave <== NOT EXECUTED 10d379: c3 ret <== NOT EXECUTED 00113214 <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 113214: 55 push %ebp <== NOT EXECUTED 113215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113217: 57 push %edi <== NOT EXECUTED 113218: 56 push %esi <== NOT EXECUTED 113219: 53 push %ebx <== NOT EXECUTED 11321a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 11321d: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 113220: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 113223: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 113226: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 113229: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 113230: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 113233: a1 30 29 13 00 mov 0x132930,%eax <== NOT EXECUTED 113238: a3 64 27 13 00 mov %eax,0x132764 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 11323d: a1 70 28 13 00 mov 0x132870,%eax <== NOT EXECUTED 113242: a3 60 27 13 00 mov %eax,0x132760 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113247: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 11324c: 40 inc %eax <== NOT EXECUTED 11324d: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Insert the timers that were inserted before we got to run. * This should be done with dispatching disabled. */ _Thread_Disable_dispatch(); _Timer_Server_process_insertions(); 113252: e8 6d ff ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED _Thread_Enable_dispatch(); 113257: e8 90 24 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 11325c: 89 f7 mov %esi,%edi <== NOT EXECUTED 11325e: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 113263: 40 inc %eax <== NOT EXECUTED 113264: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 113269: 51 push %ecx <== NOT EXECUTED 11326a: 51 push %ecx <== NOT EXECUTED 11326b: 6a 08 push $0x8 <== NOT EXECUTED 11326d: ff 35 18 2b 13 00 pushl 0x132b18 <== NOT EXECUTED 113273: e8 90 2d 00 00 call 116008 <_Thread_Set_state> <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 113278: 8b 15 54 27 13 00 mov 0x132754,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 11327e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113281: 81 fa 58 27 13 00 cmp $0x132758,%edx <== NOT EXECUTED 113287: 74 1e je 1132a7 <_Timer_Server_body+0x93> <== NOT EXECUTED 113289: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED Heap_Control *the_heap, 11328e: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 113291: 89 50 54 mov %edx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 113294: 52 push %edx <== NOT EXECUTED 113295: 52 push %edx <== NOT EXECUTED 113296: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 113299: 50 push %eax <== NOT EXECUTED 11329a: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 11329f: e8 64 35 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 1132a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1132a7: a1 68 27 13 00 mov 0x132768,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 1132ac: 3d 6c 27 13 00 cmp $0x13276c,%eax <== NOT EXECUTED 1132b1: 74 1c je 1132cf <_Timer_Server_body+0xbb> <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 1132b3: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 1132b6: a3 8c 27 13 00 mov %eax,0x13278c <== NOT EXECUTED size_t size ); 1132bb: 50 push %eax <== NOT EXECUTED 1132bc: 50 push %eax <== NOT EXECUTED 1132bd: 68 80 27 13 00 push $0x132780 <== NOT EXECUTED 1132c2: 68 b4 28 13 00 push $0x1328b4 <== NOT EXECUTED 1132c7: e8 3c 35 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 1132cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 1132cf: e8 18 24 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1132d4: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1132d9: 40 inc %eax <== NOT EXECUTED 1132da: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * At this point, at least one of the timers this task relies * upon has fired. Stop them both while we process any outstanding * timers. Before we block, we will restart them. */ _Timer_Server_stop_ticks_timer(); 1132df: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1132e2: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1132e7: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1132ea: 50 push %eax <== NOT EXECUTED 1132eb: e8 30 36 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 1132f0: c7 04 24 80 27 13 00 movl $0x132780,(%esp) <== NOT EXECUTED 1132f7: e8 24 36 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 1132fc: 8b 15 30 29 13 00 mov 0x132930,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 113302: a1 64 27 13 00 mov 0x132764,%eax <== NOT EXECUTED 113307: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11330a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11330c: 72 08 jb 113316 <_Timer_Server_body+0x102> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; 11330e: 89 d1 mov %edx,%ecx <== NOT EXECUTED 113310: 29 c1 sub %eax,%ecx <== NOT EXECUTED 113312: 89 c8 mov %ecx,%eax <== NOT EXECUTED 113314: eb 04 jmp 11331a <_Timer_Server_body+0x106> <== NOT EXECUTED else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 113316: f7 d0 not %eax <== NOT EXECUTED 113318: 01 d0 add %edx,%eax <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 11331a: 89 15 64 27 13 00 mov %edx,0x132764 <== NOT EXECUTED _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 113320: 53 push %ebx <== NOT EXECUTED 113321: 57 push %edi <== NOT EXECUTED 113322: 50 push %eax <== NOT EXECUTED 113323: 68 54 27 13 00 push $0x132754 <== NOT EXECUTED 113328: e8 4b 34 00 00 call 116778 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 11332d: 8b 1d 70 28 13 00 mov 0x132870,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 113333: a1 60 27 13 00 mov 0x132760,%eax <== NOT EXECUTED 113338: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11333b: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11333d: 76 13 jbe 113352 <_Timer_Server_body+0x13e> <== 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 ); 11333f: 51 push %ecx <== NOT EXECUTED 113340: 57 push %edi <== NOT EXECUTED 113341: 89 da mov %ebx,%edx <== NOT EXECUTED 113343: 29 c2 sub %eax,%edx <== NOT EXECUTED 113345: 52 push %edx <== NOT EXECUTED 113346: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 11334b: e8 28 34 00 00 call 116778 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 113350: eb 12 jmp 113364 <_Timer_Server_body+0x150> <== NOT EXECUTED } else if ( snapshot < _Timer_Server_seconds_last_time ) { 113352: 73 13 jae 113367 <_Timer_Server_body+0x153> <== NOT EXECUTED /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); 113354: 52 push %edx <== NOT EXECUTED 113355: 29 d8 sub %ebx,%eax <== NOT EXECUTED 113357: 50 push %eax <== NOT EXECUTED 113358: 6a 01 push $0x1 <== NOT EXECUTED 11335a: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 11335f: e8 a8 33 00 00 call 11670c <_Watchdog_Adjust> <== NOT EXECUTED 113364: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Timer_Server_seconds_last_time = snapshot; 113367: 89 1d 60 27 13 00 mov %ebx,0x132760 <== NOT EXECUTED _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 11336d: e8 52 fe ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 113372: e8 75 23 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 113377: 9c pushf <== NOT EXECUTED 113378: fa cli <== NOT EXECUTED 113379: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 11337a: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11337d: 3b 55 e0 cmp -0x20(%ebp),%edx <== NOT EXECUTED 113380: 74 0c je 11338e <_Timer_Server_body+0x17a> <== NOT EXECUTED 113382: 8b 02 mov (%edx),%eax <== NOT EXECUTED 113384: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 113387: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { 11338a: 85 d2 test %edx,%edx <== NOT EXECUTED 11338c: 75 07 jne 113395 <_Timer_Server_body+0x181> <== NOT EXECUTED _ISR_Enable( level ); 11338e: 51 push %ecx <== NOT EXECUTED 11338f: 9d popf <== NOT EXECUTED 113390: e9 c9 fe ff ff jmp 11325e <_Timer_Server_body+0x4a> <== NOT EXECUTED break; } watch->state = WATCHDOG_INACTIVE; 113395: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED _ISR_Enable( level ); 11339c: 51 push %ecx <== NOT EXECUTED 11339d: 9d popf <== NOT EXECUTED (*watch->routine)( watch->id, watch->user_data ); 11339e: 53 push %ebx <== NOT EXECUTED 11339f: 53 push %ebx <== NOT EXECUTED 1133a0: ff 72 24 pushl 0x24(%edx) <== NOT EXECUTED 1133a3: ff 72 20 pushl 0x20(%edx) <== NOT EXECUTED 1133a6: ff 52 1c call *0x1c(%edx) <== NOT EXECUTED 1133a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1133ac: eb c9 jmp 113377 <_Timer_Server_body+0x163> <== NOT EXECUTED 001131c4 <_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) { 1131c4: 55 push %ebp <== NOT EXECUTED 1131c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1131c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 1131ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1131cd: 68 74 27 13 00 push $0x132774 <== NOT EXECUTED 1131d2: e8 05 08 00 00 call 1139dc <_Chain_Get> <== NOT EXECUTED if ( the_timer == NULL ) 1131d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131da: 85 c0 test %eax,%eax <== NOT EXECUTED 1131dc: 74 34 je 113212 <_Timer_Server_process_insertions+0x4e> <== NOT EXECUTED break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1131de: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1131e1: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1131e4: 75 0d jne 1131f3 <_Timer_Server_process_insertions+0x2f> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 1131e6: 51 push %ecx <== NOT EXECUTED 1131e7: 51 push %ecx <== NOT EXECUTED 1131e8: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1131eb: 50 push %eax <== NOT EXECUTED 1131ec: 68 54 27 13 00 push $0x132754 <== NOT EXECUTED 1131f1: eb 10 jmp 113203 <_Timer_Server_process_insertions+0x3f> <== NOT EXECUTED } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 1131f3: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 1131f6: 75 13 jne 11320b <_Timer_Server_process_insertions+0x47> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 1131f8: 52 push %edx <== NOT EXECUTED 1131f9: 52 push %edx <== NOT EXECUTED 1131fa: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1131fd: 50 push %eax <== NOT EXECUTED 1131fe: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 113203: e8 00 36 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 113208: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 11320b: e8 b4 ff ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED 113210: eb b8 jmp 1131ca <_Timer_Server_process_insertions+0x6> <== NOT EXECUTED } } 113212: c9 leave <== NOT EXECUTED 113213: c3 ret <== NOT EXECUTED 0011318b <_Timer_Server_schedule_operation_method>: * the directive invoking this is executed. */ static void _Timer_Server_schedule_operation_method( Timer_Control *the_timer ) { 11318b: 55 push %ebp <== NOT EXECUTED 11318c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11318e: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node ); 113191: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113194: 68 74 27 13 00 push $0x132774 <== NOT EXECUTED 113199: e8 1a 08 00 00 call 1139b8 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 11319e: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1131a3: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1131a6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1131a9: e8 72 37 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Thread_Delay_ended( _Timer_Server->Object.id, NULL ); 1131ae: 59 pop %ecx <== NOT EXECUTED 1131af: 58 pop %eax <== NOT EXECUTED 1131b0: 6a 00 push $0x0 <== NOT EXECUTED 1131b2: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1131b7: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1131ba: e8 b1 23 00 00 call 115570 <_Thread_Delay_ended> <== NOT EXECUTED 1131bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1131c2: c9 leave <== NOT EXECUTED 1131c3: c3 ret <== NOT EXECUTED 0010b8e8 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10b8e8: 55 push %ebp <== NOT EXECUTED 10b8e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b8eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8ee: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10b8f1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10b8f3: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10b8f5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b8f8: 01 42 04 add %eax,0x4(%edx) <== NOT EXECUTED 10b8fb: eb 0b jmp 10b908 <_Timespec_Add_to+0x20> <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10b8fd: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10b902: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10b905: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10b907: 41 inc %ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10b908: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b90b: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10b910: 77 eb ja 10b8fd <_Timespec_Add_to+0x15> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10b912: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b914: c9 leave <== NOT EXECUTED 10b915: c3 ret <== NOT EXECUTED 0010ce38 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10ce38: 55 push %ebp <== NOT EXECUTED 10ce39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce3b: 57 push %edi <== NOT EXECUTED 10ce3c: 56 push %esi <== NOT EXECUTED 10ce3d: 53 push %ebx <== NOT EXECUTED 10ce3e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ce41: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce44: 8b 18 mov (%eax),%ebx <== NOT EXECUTED left += lhs->tv_nsec; 10ce46: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ce49: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce4c: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10ce51: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ce54: f7 29 imull (%ecx) <== NOT EXECUTED 10ce56: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ce58: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10ce5a: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ce5d: 99 cltd <== NOT EXECUTED 10ce5e: 01 c6 add %eax,%esi <== NOT EXECUTED 10ce60: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10ce62: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ce64: 09 f0 or %esi,%eax <== NOT EXECUTED 10ce66: 75 14 jne 10ce7c <_Timespec_Divide+0x44> <== NOT EXECUTED *ival_percentage = 0; 10ce68: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ce6b: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10ce71: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10ce74: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 10ce7a: eb 70 jmp 10ceec <_Timespec_Divide+0xb4> <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce7c: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10ce81: f7 eb imul %ebx <== NOT EXECUTED 10ce83: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10ce86: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10ce89: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10ce8c: 99 cltd <== NOT EXECUTED 10ce8d: 01 45 e8 add %eax,-0x18(%ebp) <== NOT EXECUTED 10ce90: 11 55 ec adc %edx,-0x14(%ebp) <== NOT EXECUTED 10ce93: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx <== NOT EXECUTED 10ce9a: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10ce9f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10cea2: f7 e1 mul %ecx <== NOT EXECUTED 10cea4: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10cea7: 01 da add %ebx,%edx <== NOT EXECUTED 10cea9: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 10ceac: 57 push %edi <== NOT EXECUTED 10cead: 56 push %esi <== NOT EXECUTED 10ceae: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10ceb1: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 10ceb4: e8 8f a4 00 00 call 117348 <__udivdi3> <== NOT EXECUTED 10ceb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cebc: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10cebe: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10cec0: 6a 00 push $0x0 <== NOT EXECUTED 10cec2: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cec7: 52 push %edx <== NOT EXECUTED 10cec8: 50 push %eax <== NOT EXECUTED 10cec9: e8 7a a4 00 00 call 117348 <__udivdi3> <== NOT EXECUTED 10cece: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ced1: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ced4: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10ced6: 6a 00 push $0x0 <== NOT EXECUTED 10ced8: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cedd: 56 push %esi <== NOT EXECUTED 10cede: 53 push %ebx <== NOT EXECUTED 10cedf: e8 70 a5 00 00 call 117454 <__umoddi3> <== NOT EXECUTED 10cee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cee7: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10ceea: 89 01 mov %eax,(%ecx) <== NOT EXECUTED } 10ceec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ceef: 5b pop %ebx <== NOT EXECUTED 10cef0: 5e pop %esi <== NOT EXECUTED 10cef1: 5f pop %edi <== NOT EXECUTED 10cef2: c9 leave <== NOT EXECUTED 10cef3: c3 ret <== NOT EXECUTED 00122208 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 122208: 55 push %ebp <== NOT EXECUTED 122209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12220b: 57 push %edi <== NOT EXECUTED 12220c: 56 push %esi <== NOT EXECUTED 12220d: 53 push %ebx <== NOT EXECUTED 12220e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122211: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 122214: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 122217: 8b 06 mov (%esi),%eax <== NOT EXECUTED 122219: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 12221a: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 122220: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 122225: f7 e1 mul %ecx <== NOT EXECUTED 122227: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 12222a: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 12222d: 89 cb mov %ecx,%ebx <== NOT EXECUTED 12222f: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 122232: 01 c8 add %ecx,%eax <== NOT EXECUTED 122234: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 122236: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 122239: 31 db xor %ebx,%ebx <== NOT EXECUTED 12223b: 53 push %ebx <== NOT EXECUTED 12223c: 51 push %ecx <== NOT EXECUTED 12223d: 52 push %edx <== NOT EXECUTED 12223e: 50 push %eax <== NOT EXECUTED 12223f: e8 98 66 01 00 call 1388dc <__udivdi3> <== NOT EXECUTED 122244: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122247: 89 c3 mov %eax,%ebx <== NOT EXECUTED 122249: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 12224b: 6a 00 push $0x0 <== NOT EXECUTED 12224d: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 122252: 52 push %edx <== NOT EXECUTED 122253: 50 push %eax <== NOT EXECUTED 122254: e8 83 66 01 00 call 1388dc <__udivdi3> <== NOT EXECUTED 122259: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12225c: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 12225e: 6a 00 push $0x0 <== NOT EXECUTED 122260: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 122265: 56 push %esi <== NOT EXECUTED 122266: 53 push %ebx <== NOT EXECUTED 122267: e8 7c 67 01 00 call 1389e8 <__umoddi3> <== NOT EXECUTED 12226c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12226f: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 122272: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122275: 5b pop %ebx <== NOT EXECUTED 122276: 5e pop %esi <== NOT EXECUTED 122277: 5f pop %edi <== NOT EXECUTED 122278: c9 leave <== NOT EXECUTED 122279: c3 ret <== NOT EXECUTED 001133cc <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 1133cc: 55 push %ebp <== NOT EXECUTED 1133cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133cf: 56 push %esi <== NOT EXECUTED 1133d0: 53 push %ebx <== NOT EXECUTED 1133d1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1133d4: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 1133d7: 0f af 1d 20 8a 12 00 imul 0x128a20,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 1133de: be 40 42 0f 00 mov $0xf4240,%esi <== NOT EXECUTED 1133e3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1133e5: 31 d2 xor %edx,%edx <== NOT EXECUTED 1133e7: f7 f6 div %esi <== NOT EXECUTED 1133e9: 89 01 mov %eax,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 1133eb: 69 c2 e8 03 00 00 imul $0x3e8,%edx,%eax <== NOT EXECUTED 1133f1: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 1133f4: 5b pop %ebx <== NOT EXECUTED 1133f5: 5e pop %esi <== NOT EXECUTED 1133f6: c9 leave <== NOT EXECUTED 1133f7: c3 ret <== NOT EXECUTED 0010d180 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10d180: 55 push %ebp <== NOT EXECUTED 10d181: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d183: 53 push %ebx <== NOT EXECUTED 10d184: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d187: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10d18a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d18c: b2 01 mov $0x1,%dl <== NOT EXECUTED 10d18e: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10d190: 7f 0f jg 10d1a1 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10d192: 7d 04 jge 10d198 <_Timespec_Greater_than+0x18> <== NOT EXECUTED 10d194: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d196: eb 09 jmp 10d1a1 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10d198: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d19b: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10d19e: 0f 9f c2 setg %dl <== NOT EXECUTED return TRUE; return FALSE; } 10d1a1: 88 d0 mov %dl,%al <== NOT EXECUTED 10d1a3: 5b pop %ebx <== NOT EXECUTED 10d1a4: c9 leave <== NOT EXECUTED 10d1a5: c3 ret <== NOT EXECUTED 001133f8 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 1133f8: 55 push %ebp <== NOT EXECUTED 1133f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133fb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 1133fe: 85 c0 test %eax,%eax <== NOT EXECUTED 113400: 74 16 je 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 113402: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 113405: 78 11 js 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 113407: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 11340a: 85 c0 test %eax,%eax <== NOT EXECUTED 11340c: 78 0a js 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED 11340e: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 113413: 0f 96 c0 setbe %al <== NOT EXECUTED 113416: eb 02 jmp 11341a <_Timespec_Is_valid+0x22> <== NOT EXECUTED 113418: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11341a: c9 leave <== NOT EXECUTED 11341b: c3 ret <== NOT EXECUTED 0010d1a8 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10d1a8: 55 push %ebp <== NOT EXECUTED 10d1a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1ab: 53 push %ebx <== NOT EXECUTED 10d1ac: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d1af: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10d1b2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d1b4: b2 01 mov $0x1,%dl <== NOT EXECUTED 10d1b6: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10d1b8: 7c 0f jl 10d1c9 <_Timespec_Less_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10d1ba: 7e 04 jle 10d1c0 <_Timespec_Less_than+0x18> <== NOT EXECUTED 10d1bc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d1be: eb 09 jmp 10d1c9 <_Timespec_Less_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10d1c0: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d1c3: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10d1c6: 0f 9c c2 setl %dl <== NOT EXECUTED return TRUE; return FALSE; } 10d1c9: 88 d0 mov %dl,%al <== NOT EXECUTED 10d1cb: 5b pop %ebx <== NOT EXECUTED 10d1cc: c9 leave <== NOT EXECUTED 10d1cd: c3 ret <== NOT EXECUTED 0010b918 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10b918: 55 push %ebp <== NOT EXECUTED 10b919: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b91b: 53 push %ebx <== NOT EXECUTED 10b91c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b91f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b922: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10b925: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10b928: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10b92b: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10b92d: 7d 13 jge 10b942 <_Timespec_Subtract+0x2a> <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 10b92f: 48 dec %eax <== NOT EXECUTED 10b930: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b932: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10b934: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10b93a: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10b93d: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10b940: eb 0a jmp 10b94c <_Timespec_Subtract+0x34> <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; 10b942: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b944: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10b946: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10b949: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10b94c: 5b pop %ebx <== NOT EXECUTED 10b94d: c9 leave <== NOT EXECUTED 10b94e: c3 ret <== NOT EXECUTED 0011341c <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 11341c: 55 push %ebp <== NOT EXECUTED 11341d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11341f: 57 push %edi <== NOT EXECUTED 113420: 56 push %esi <== NOT EXECUTED 113421: 53 push %ebx <== NOT EXECUTED 113422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113425: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 113428: 8b 31 mov (%ecx),%esi <== NOT EXECUTED 11342a: 85 f6 test %esi,%esi <== NOT EXECUTED 11342c: 75 08 jne 113436 <_Timespec_To_ticks+0x1a> <== NOT EXECUTED 11342e: 31 c0 xor %eax,%eax <== NOT EXECUTED 113430: 83 79 04 00 cmpl $0x0,0x4(%ecx) <== NOT EXECUTED 113434: 74 2f je 113465 <_Timespec_To_ticks+0x49> <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 113436: 8b 1d 20 8a 12 00 mov 0x128a20,%ebx <== NOT EXECUTED 11343c: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 113441: 89 f8 mov %edi,%eax <== NOT EXECUTED 113443: 31 d2 xor %edx,%edx <== NOT EXECUTED 113445: f7 f3 div %ebx <== NOT EXECUTED 113447: 89 c7 mov %eax,%edi <== NOT EXECUTED 113449: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 11344c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 11344f: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 113454: 31 d2 xor %edx,%edx <== NOT EXECUTED 113456: f7 f1 div %ecx <== NOT EXECUTED 113458: 31 d2 xor %edx,%edx <== NOT EXECUTED 11345a: f7 f3 div %ebx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 11345c: 01 f8 add %edi,%eax <== NOT EXECUTED 11345e: 75 05 jne 113465 <_Timespec_To_ticks+0x49> <== NOT EXECUTED 113460: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 113465: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113468: 5b pop %ebx <== NOT EXECUTED 113469: 5e pop %esi <== NOT EXECUTED 11346a: 5f pop %edi <== NOT EXECUTED 11346b: c9 leave <== NOT EXECUTED 11346c: c3 ret <== NOT EXECUTED 0010ddfc <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10ddfc: 55 push %ebp <== NOT EXECUTED 10ddfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddff: 53 push %ebx <== NOT EXECUTED 10de00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de03: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10de06: 53 push %ebx <== NOT EXECUTED 10de07: 68 18 cc 11 00 push $0x11cc18 <== NOT EXECUTED 10de0c: e8 0f bc ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10de11: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10de14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de17: 85 c0 test %eax,%eax <== NOT EXECUTED 10de19: 74 16 je 10de31 <_User_extensions_Add_API_set+0x35> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10de1b: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10de1e: 50 push %eax <== NOT EXECUTED 10de1f: 50 push %eax <== NOT EXECUTED 10de20: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10de23: 50 push %eax <== NOT EXECUTED 10de24: 68 04 ca 11 00 push $0x11ca04 <== NOT EXECUTED 10de29: e8 f2 bb ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED 10de2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10de34: c9 leave <== NOT EXECUTED 10de35: c3 ret <== NOT EXECUTED 0010de38 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10de38: 55 push %ebp <== NOT EXECUTED 10de39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de3b: 57 push %edi <== NOT EXECUTED 10de3c: 56 push %esi <== NOT EXECUTED 10de3d: 53 push %ebx <== NOT EXECUTED 10de3e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10de41: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10de44: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de47: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10de4a: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10de4d: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10de52: 89 c6 mov %eax,%esi <== NOT EXECUTED 10de54: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10de56: 53 push %ebx <== NOT EXECUTED 10de57: 68 18 cc 11 00 push $0x11cc18 <== NOT EXECUTED 10de5c: e8 bf bb ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10de61: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10de64: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10de67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de6a: 85 c0 test %eax,%eax <== NOT EXECUTED 10de6c: 74 1c je 10de8a <_User_extensions_Add_set+0x52> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10de6e: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10de71: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10de74: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10de77: c7 45 08 04 ca 11 00 movl $0x11ca04,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de7e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de81: 5b pop %ebx <== NOT EXECUTED 10de82: 5e pop %esi <== NOT EXECUTED 10de83: 5f pop %edi <== NOT EXECUTED 10de84: c9 leave <== NOT EXECUTED * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { the_extension->Switch.thread_switch = extension_table->thread_switch; _Chain_Append( 10de85: e9 96 bb ff ff jmp 109a20 <_Chain_Append> <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de8a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de8d: 5b pop %ebx <== NOT EXECUTED 10de8e: 5e pop %esi <== NOT EXECUTED 10de8f: 5f pop %edi <== NOT EXECUTED 10de90: c9 leave <== NOT EXECUTED 10de91: c3 ret <== NOT EXECUTED 0010ba3f <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10ba3f: 55 push %ebp <== NOT EXECUTED 10ba40: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba42: 57 push %edi <== NOT EXECUTED 10ba43: 56 push %esi <== NOT EXECUTED 10ba44: 53 push %ebx <== NOT EXECUTED 10ba45: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba48: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10ba4b: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10ba51: 0f b6 75 0c movzbl 0xc(%ebp),%esi <== NOT EXECUTED 10ba55: eb 15 jmp 10ba6c <_User_extensions_Fatal+0x2d> <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 10ba57: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10ba5a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba5c: 74 0b je 10ba69 <_User_extensions_Fatal+0x2a> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10ba5e: 52 push %edx <== NOT EXECUTED 10ba5f: 57 push %edi <== NOT EXECUTED 10ba60: 56 push %esi <== NOT EXECUTED 10ba61: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ba64: ff d0 call *%eax <== NOT EXECUTED 10ba66: 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 ) { 10ba69: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10ba6c: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10ba72: 75 e3 jne 10ba57 <_User_extensions_Fatal+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10ba74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba77: 5b pop %ebx <== NOT EXECUTED 10ba78: 5e pop %esi <== NOT EXECUTED 10ba79: 5f pop %edi <== NOT EXECUTED 10ba7a: c9 leave <== NOT EXECUTED 10ba7b: c3 ret <== NOT EXECUTED 0010b950 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10b950: 55 push %ebp <== NOT EXECUTED 10b951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b953: 57 push %edi <== NOT EXECUTED 10b954: 56 push %esi <== NOT EXECUTED 10b955: 53 push %ebx <== NOT EXECUTED 10b956: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b959: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b95c: c7 05 18 cc 11 00 1c movl $0x11cc1c,0x11cc18 <== NOT EXECUTED 10b963: cc 11 00 <== NOT EXECUTED 10b966: c7 05 1c cc 11 00 00 movl $0x0,0x11cc1c <== NOT EXECUTED 10b96d: 00 00 00 <== NOT EXECUTED 10b970: c7 05 20 cc 11 00 18 movl $0x11cc18,0x11cc20 <== NOT EXECUTED 10b977: cc 11 00 <== NOT EXECUTED 10b97a: c7 05 04 ca 11 00 08 movl $0x11ca08,0x11ca04 <== NOT EXECUTED 10b981: ca 11 00 <== NOT EXECUTED 10b984: c7 05 08 ca 11 00 00 movl $0x0,0x11ca08 <== NOT EXECUTED 10b98b: 00 00 00 <== NOT EXECUTED 10b98e: c7 05 0c ca 11 00 04 movl $0x11ca04,0x11ca0c <== NOT EXECUTED 10b995: ca 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10b998: 85 f6 test %esi,%esi <== NOT EXECUTED 10b99a: 74 38 je 10b9d4 <_User_extensions_Handler_initialization+0x84> <== NOT EXECUTED extension = (User_extensions_Control *) 10b99c: 6b 5d 08 34 imul $0x34,0x8(%ebp),%ebx <== NOT EXECUTED 10b9a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9a3: 53 push %ebx <== NOT EXECUTED 10b9a4: e8 c9 03 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b9a9: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10b9ac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9ae: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10b9b1: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10b9b3: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9b5: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b9b7: eb 13 jmp 10b9cc <_User_extensions_Handler_initialization+0x7c> <== NOT EXECUTED 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { _User_extensions_Add_set (extension, &initial_extensions[i]); 10b9b9: 50 push %eax <== NOT EXECUTED 10b9ba: 50 push %eax <== NOT EXECUTED 10b9bb: 56 push %esi <== NOT EXECUTED 10b9bc: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10b9bf: e8 74 24 00 00 call 10de38 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10b9c4: 83 45 ec 34 addl $0x34,-0x14(%ebp) <== NOT EXECUTED extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10b9c8: 43 inc %ebx <== NOT EXECUTED 10b9c9: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b9cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9cf: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10b9d2: 72 e5 jb 10b9b9 <_User_extensions_Handler_initialization+0x69> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10b9d4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b9d7: 5b pop %ebx <== NOT EXECUTED 10b9d8: 5e pop %esi <== NOT EXECUTED 10b9d9: 5f pop %edi <== NOT EXECUTED 10b9da: c9 leave <== NOT EXECUTED 10b9db: c3 ret <== NOT EXECUTED 0010f0e0 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10f0e0: 55 push %ebp <== NOT EXECUTED 10f0e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f0e3: 53 push %ebx <== NOT EXECUTED 10f0e4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f0e7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 10f0ea: 53 push %ebx <== NOT EXECUTED 10f0eb: e8 0c 38 00 00 call 1128fc <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10f0f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f0f3: 83 7b 24 00 cmpl $0x0,0x24(%ebx) <== NOT EXECUTED 10f0f7: 74 0f je 10f108 <_User_extensions_Remove_set+0x28> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 10f0f9: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f0fc: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f0ff: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f102: 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 ); 10f103: e9 f4 37 00 00 jmp 1128fc <_Chain_Extract> <== NOT EXECUTED } 10f108: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f10b: c9 leave <== NOT EXECUTED 10f10c: c3 ret <== NOT EXECUTED 0010b9dc <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10b9dc: 55 push %ebp <== NOT EXECUTED 10b9dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9df: 56 push %esi <== NOT EXECUTED 10b9e0: 53 push %ebx <== NOT EXECUTED 10b9e1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10b9e4: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10b9ea: eb 12 jmp 10b9fe <_User_extensions_Thread_begin+0x22> <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10b9ec: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10b9ef: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9f1: 74 09 je 10b9fc <_User_extensions_Thread_begin+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10b9f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9f6: 56 push %esi <== NOT EXECUTED 10b9f7: ff d0 call *%eax <== NOT EXECUTED 10b9f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10b9fc: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10b9fe: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10ba04: 75 e6 jne 10b9ec <_User_extensions_Thread_begin+0x10> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10ba06: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ba09: 5b pop %ebx <== NOT EXECUTED 10ba0a: 5e pop %esi <== NOT EXECUTED 10ba0b: c9 leave <== NOT EXECUTED 10ba0c: c3 ret <== NOT EXECUTED 0010ba7c <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10ba7c: 55 push %ebp <== NOT EXECUTED 10ba7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba7f: 56 push %esi <== NOT EXECUTED 10ba80: 53 push %ebx <== NOT EXECUTED 10ba81: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; 10ba84: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10ba8a: eb 1b jmp 10baa7 <_User_extensions_Thread_create+0x2b> <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10ba8c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10ba8f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba91: 74 12 je 10baa5 <_User_extensions_Thread_create+0x29> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10ba93: 52 push %edx <== NOT EXECUTED 10ba94: 52 push %edx <== NOT EXECUTED 10ba95: 56 push %esi <== NOT EXECUTED 10ba96: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10ba9c: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10ba9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10baa1: 84 c0 test %al,%al <== NOT EXECUTED 10baa3: 74 0c je 10bab1 <_User_extensions_Thread_create+0x35> <== NOT EXECUTED User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10baa5: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10baa7: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10baad: 75 dd jne 10ba8c <_User_extensions_Thread_create+0x10> <== NOT EXECUTED 10baaf: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10bab1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bab4: 5b pop %ebx <== NOT EXECUTED 10bab5: 5e pop %esi <== NOT EXECUTED 10bab6: c9 leave <== NOT EXECUTED 10bab7: c3 ret <== NOT EXECUTED 0010bab8 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10bab8: 55 push %ebp <== NOT EXECUTED 10bab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10babb: 56 push %esi <== NOT EXECUTED 10babc: 53 push %ebx <== NOT EXECUTED 10babd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10bac0: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED 10bac6: eb 18 jmp 10bae0 <_User_extensions_Thread_delete+0x28> <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10bac8: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10bacb: 85 c0 test %eax,%eax <== NOT EXECUTED 10bacd: 74 0e je 10badd <_User_extensions_Thread_delete+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10bacf: 52 push %edx <== NOT EXECUTED 10bad0: 52 push %edx <== NOT EXECUTED 10bad1: 56 push %esi <== NOT EXECUTED 10bad2: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10bad8: ff d0 call *%eax <== NOT EXECUTED 10bada: 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 ) { 10badd: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10bae0: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10bae6: 75 e0 jne 10bac8 <_User_extensions_Thread_delete+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10bae8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10baeb: 5b pop %ebx <== NOT EXECUTED 10baec: 5e pop %esi <== NOT EXECUTED 10baed: c9 leave <== NOT EXECUTED 10baee: c3 ret <== NOT EXECUTED 0010ba0d <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10ba0d: 55 push %ebp <== NOT EXECUTED 10ba0e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba10: 56 push %esi <== NOT EXECUTED 10ba11: 53 push %ebx <== NOT EXECUTED 10ba12: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10ba15: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED 10ba1b: eb 13 jmp 10ba30 <_User_extensions_Thread_exitted+0x23> <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10ba1d: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10ba20: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba22: 74 09 je 10ba2d <_User_extensions_Thread_exitted+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10ba24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba27: 56 push %esi <== NOT EXECUTED 10ba28: ff d0 call *%eax <== NOT EXECUTED 10ba2a: 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 ) { 10ba2d: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10ba30: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10ba36: 75 e5 jne 10ba1d <_User_extensions_Thread_exitted+0x10> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10ba38: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ba3b: 5b pop %ebx <== NOT EXECUTED 10ba3c: 5e pop %esi <== NOT EXECUTED 10ba3d: c9 leave <== NOT EXECUTED 10ba3e: c3 ret <== NOT EXECUTED 0010c514 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10c514: 55 push %ebp <== NOT EXECUTED 10c515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c517: 56 push %esi <== NOT EXECUTED 10c518: 53 push %ebx <== NOT EXECUTED 10c519: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10c51c: 8b 1d 84 fc 11 00 mov 0x11fc84,%ebx <== NOT EXECUTED 10c522: eb 17 jmp 10c53b <_User_extensions_Thread_restart+0x27> <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10c524: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10c527: 85 c0 test %eax,%eax <== NOT EXECUTED 10c529: 74 0e je 10c539 <_User_extensions_Thread_restart+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10c52b: 52 push %edx <== NOT EXECUTED 10c52c: 52 push %edx <== NOT EXECUTED 10c52d: 56 push %esi <== NOT EXECUTED 10c52e: ff 35 2c fb 11 00 pushl 0x11fb2c <== NOT EXECUTED 10c534: ff d0 call *%eax <== NOT EXECUTED 10c536: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10c539: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10c53b: 81 fb 88 fc 11 00 cmp $0x11fc88,%ebx <== NOT EXECUTED 10c541: 75 e1 jne 10c524 <_User_extensions_Thread_restart+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10c543: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c546: 5b pop %ebx <== NOT EXECUTED 10c547: 5e pop %esi <== NOT EXECUTED 10c548: c9 leave <== NOT EXECUTED 10c549: c3 ret <== NOT EXECUTED 0010baf0 <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10baf0: 55 push %ebp <== NOT EXECUTED 10baf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10baf3: 56 push %esi <== NOT EXECUTED 10baf4: 53 push %ebx <== NOT EXECUTED 10baf5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10baf8: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10bafe: eb 17 jmp 10bb17 <_User_extensions_Thread_start+0x27> <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10bb00: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10bb03: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb05: 74 0e je 10bb15 <_User_extensions_Thread_start+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10bb07: 52 push %edx <== NOT EXECUTED 10bb08: 52 push %edx <== NOT EXECUTED 10bb09: 56 push %esi <== NOT EXECUTED 10bb0a: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10bb10: ff d0 call *%eax <== NOT EXECUTED 10bb12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10bb15: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10bb17: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10bb1d: 75 e1 jne 10bb00 <_User_extensions_Thread_start+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10bb1f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bb22: 5b pop %ebx <== NOT EXECUTED 10bb23: 5e pop %esi <== NOT EXECUTED 10bb24: c9 leave <== NOT EXECUTED 10bb25: c3 ret <== NOT EXECUTED 0010bb28 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10bb28: 55 push %ebp <== NOT EXECUTED 10bb29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb2b: 57 push %edi <== NOT EXECUTED 10bb2c: 56 push %esi <== NOT EXECUTED 10bb2d: 53 push %ebx <== NOT EXECUTED 10bb2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bb31: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bb34: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; 10bb37: 8b 1d 04 ca 11 00 mov 0x11ca04,%ebx <== NOT EXECUTED 10bb3d: eb 0c jmp 10bb4b <_User_extensions_Thread_switch+0x23> <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10bb3f: 50 push %eax <== NOT EXECUTED 10bb40: 50 push %eax <== NOT EXECUTED 10bb41: 56 push %esi <== NOT EXECUTED 10bb42: 57 push %edi <== NOT EXECUTED 10bb43: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10bb46: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bb48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10bb4b: 81 fb 08 ca 11 00 cmp $0x11ca08,%ebx <== NOT EXECUTED 10bb51: 75 ec jne 10bb3f <_User_extensions_Thread_switch+0x17> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10bb53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bb56: 5b pop %ebx <== NOT EXECUTED 10bb57: 5e pop %esi <== NOT EXECUTED 10bb58: 5f pop %edi <== NOT EXECUTED 10bb59: c9 leave <== NOT EXECUTED 10bb5a: c3 ret <== NOT EXECUTED 0010d194 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10d194: 55 push %ebp <== NOT EXECUTED 10d195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d197: 57 push %edi <== NOT EXECUTED 10d198: 56 push %esi <== NOT EXECUTED 10d199: 53 push %ebx <== NOT EXECUTED 10d19a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d19d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d1a0: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d1a3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10d1a6: 9c pushf <== NOT EXECUTED 10d1a7: fa cli <== NOT EXECUTED 10d1a8: 5a pop %edx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10d1a9: 8b 07 mov (%edi),%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10d1ab: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10d1ae: 89 5d f0 mov %ebx,-0x10(%ebp) <== NOT EXECUTED * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10d1b1: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10d1b3: 74 41 je 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED switch ( direction ) { 10d1b5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d1b7: 74 39 je 10d1f2 <_Watchdog_Adjust+0x5e> <== NOT EXECUTED 10d1b9: 49 dec %ecx <== NOT EXECUTED 10d1ba: 75 3a jne 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10d1bc: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10d1bf: eb 35 jmp 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED 10d1c1: 8b 07 mov (%edi),%eax <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10d1c3: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10d1c6: 39 de cmp %ebx,%esi <== NOT EXECUTED 10d1c8: 73 07 jae 10d1d1 <_Watchdog_Adjust+0x3d> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 10d1ca: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10d1cc: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10d1cf: eb 25 jmp 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10d1d1: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10d1d8: 52 push %edx <== NOT EXECUTED 10d1d9: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10d1da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1dd: 57 push %edi <== NOT EXECUTED 10d1de: e8 9d 01 00 00 call 10d380 <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10d1e3: 9c pushf <== NOT EXECUTED 10d1e4: fa cli <== NOT EXECUTED 10d1e5: 5a pop %edx <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d1e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1e9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d1ec: 39 07 cmp %eax,(%edi) <== NOT EXECUTED 10d1ee: 74 06 je 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 10d1f0: 29 de sub %ebx,%esi <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10d1f2: 85 f6 test %esi,%esi <== NOT EXECUTED 10d1f4: 75 cb jne 10d1c1 <_Watchdog_Adjust+0x2d> <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10d1f6: 52 push %edx <== NOT EXECUTED 10d1f7: 9d popf <== NOT EXECUTED } 10d1f8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d1fb: 5b pop %ebx <== NOT EXECUTED 10d1fc: 5e pop %esi <== NOT EXECUTED 10d1fd: 5f pop %edi <== NOT EXECUTED 10d1fe: c9 leave <== NOT EXECUTED 10d1ff: c3 ret <== NOT EXECUTED 00116778 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 116778: 55 push %ebp <== NOT EXECUTED 116779: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11677b: 57 push %edi <== NOT EXECUTED 11677c: 56 push %esi <== NOT EXECUTED 11677d: 53 push %ebx <== NOT EXECUTED 11677e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116781: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 116784: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 116787: 85 c0 test %eax,%eax <== NOT EXECUTED 116789: 74 74 je 1167ff <_Watchdog_Adjust_to_chain+0x87> <== NOT EXECUTED return; } _ISR_Disable( level ); 11678b: 9c pushf <== NOT EXECUTED 11678c: fa cli <== NOT EXECUTED 11678d: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 116790: 8d 7e 04 lea 0x4(%esi),%edi <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 116793: 39 3e cmp %edi,(%esi) <== NOT EXECUTED 116795: 74 64 je 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 116797: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11679a: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 11679d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 1167a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1167a2: 8b 06 mov (%esi),%eax <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 1167a4: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED 1167a7: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 1167a9: 73 07 jae 1167b2 <_Watchdog_Adjust_to_chain+0x3a> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 1167ab: 29 d9 sub %ebx,%ecx <== NOT EXECUTED 1167ad: 89 48 10 mov %ecx,0x10(%eax) <== NOT EXECUTED 1167b0: eb 49 jmp 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 1167b2: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1167b9: 8b 16 mov (%esi),%edx <== NOT EXECUTED 1167bb: 39 fa cmp %edi,%edx <== NOT EXECUTED 1167bd: 75 04 jne 1167c3 <_Watchdog_Adjust_to_chain+0x4b> <== NOT EXECUTED 1167bf: 31 d2 xor %edx,%edx <== NOT EXECUTED 1167c1: eb 07 jmp 1167ca <_Watchdog_Adjust_to_chain+0x52> <== NOT EXECUTED 1167c3: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1167c5: 89 06 mov %eax,(%esi) <== NOT EXECUTED 1167c7: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED 1167ca: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1167cd: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1167cf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1167d2: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 1167d5: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1167d8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1167db: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 1167de: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1167e1: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1167e3: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 1167e6: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1167e9: 9d popf <== NOT EXECUTED 1167ea: fa cli <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1167eb: 8b 06 mov (%esi),%eax <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 1167ed: 39 f8 cmp %edi,%eax <== NOT EXECUTED 1167ef: 74 0a je 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 1167f1: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 1167f5: 74 c2 je 1167b9 <_Watchdog_Adjust_to_chain+0x41> <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 1167f7: 29 cb sub %ecx,%ebx <== NOT EXECUTED 1167f9: 75 a7 jne 1167a2 <_Watchdog_Adjust_to_chain+0x2a> <== NOT EXECUTED break; } } } _ISR_Enable( level ); 1167fb: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1167fe: 9d popf <== NOT EXECUTED } 1167ff: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116802: 5b pop %ebx <== NOT EXECUTED 116803: 5e pop %esi <== NOT EXECUTED 116804: 5f pop %edi <== NOT EXECUTED 116805: c9 leave <== NOT EXECUTED 116806: c3 ret <== NOT EXECUTED 0010bc14 <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10bc14: 55 push %ebp <== NOT EXECUTED 10bc15: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10bc17: c7 05 4c cb 11 00 00 movl $0x0,0x11cb4c <== NOT EXECUTED 10bc1e: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10bc21: c7 05 bc ca 11 00 00 movl $0x0,0x11cabc <== NOT EXECUTED 10bc28: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10bc2b: c7 05 50 cb 11 00 00 movl $0x0,0x11cb50 <== NOT EXECUTED 10bc32: 00 00 00 <== NOT EXECUTED 10bc35: c7 05 e0 ca 11 00 e4 movl $0x11cae4,0x11cae0 <== NOT EXECUTED 10bc3c: ca 11 00 <== NOT EXECUTED 10bc3f: c7 05 e4 ca 11 00 00 movl $0x0,0x11cae4 <== NOT EXECUTED 10bc46: 00 00 00 <== NOT EXECUTED 10bc49: c7 05 e8 ca 11 00 e0 movl $0x11cae0,0x11cae8 <== NOT EXECUTED 10bc50: ca 11 00 <== NOT EXECUTED 10bc53: c7 05 d4 ca 11 00 d8 movl $0x11cad8,0x11cad4 <== NOT EXECUTED 10bc5a: ca 11 00 <== NOT EXECUTED 10bc5d: c7 05 d8 ca 11 00 00 movl $0x0,0x11cad8 <== NOT EXECUTED 10bc64: 00 00 00 <== NOT EXECUTED 10bc67: c7 05 dc ca 11 00 d4 movl $0x11cad4,0x11cadc <== NOT EXECUTED 10bc6e: ca 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10bc71: c9 leave <== NOT EXECUTED 10bc72: c3 ret <== NOT EXECUTED 0010bb5c <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10bb5c: 55 push %ebp <== NOT EXECUTED 10bb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb5f: 57 push %edi <== NOT EXECUTED 10bb60: 56 push %esi <== NOT EXECUTED 10bb61: 53 push %ebx <== NOT EXECUTED 10bb62: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb65: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10bb68: 8b 3d 9c ca 11 00 mov 0x11ca9c,%edi <== NOT EXECUTED _ISR_Disable( level ); 10bb6e: 9c pushf <== NOT EXECUTED 10bb6f: fa cli <== NOT EXECUTED 10bb70: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 10bb73: 83 7e 08 00 cmpl $0x0,0x8(%esi) <== NOT EXECUTED 10bb77: 74 09 je 10bb82 <_Watchdog_Insert+0x26> <== NOT EXECUTED _ISR_Enable( level ); 10bb79: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bb7c: 9d popf <== NOT EXECUTED 10bb7d: e9 89 00 00 00 jmp 10bc0b <_Watchdog_Insert+0xaf> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10bb82: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10bb89: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bb8e: 40 inc %eax <== NOT EXECUTED 10bb8f: a3 4c cb 11 00 mov %eax,0x11cb4c <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10bb94: 8b 4e 0c mov 0xc(%esi),%ecx <== NOT EXECUTED * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10bb97: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb9a: 8b 18 mov (%eax),%ebx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10bb9c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb9e: 74 35 je 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED 10bba0: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10bba3: 74 30 je 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10bba5: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 10bba8: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10bbaa: 73 07 jae 10bbb3 <_Watchdog_Insert+0x57> <== NOT EXECUTED after->delta_interval -= delta_interval; 10bbac: 29 ca sub %ecx,%edx <== NOT EXECUTED 10bbae: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10bbb1: eb 22 jmp 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 10bbb3: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bbb6: 9d popf <== NOT EXECUTED 10bbb7: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10bbb8: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10bbbc: 75 38 jne 10bbf6 <_Watchdog_Insert+0x9a> <== NOT EXECUTED goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10bbbe: a1 bc ca 11 00 mov 0x11cabc,%eax <== NOT EXECUTED 10bbc3: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10bbc5: 76 08 jbe 10bbcf <_Watchdog_Insert+0x73> <== NOT EXECUTED _Watchdog_Sync_level = insert_isr_nest_level; 10bbc7: 89 3d bc ca 11 00 mov %edi,0x11cabc <== NOT EXECUTED 10bbcd: eb c5 jmp 10bb94 <_Watchdog_Insert+0x38> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10bbcf: 29 d1 sub %edx,%ecx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bbd1: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bbd3: eb c7 jmp 10bb9c <_Watchdog_Insert+0x40> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10bbd5: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10bbdc: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10bbdf: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bbe2: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10bbe5: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bbe7: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10bbe9: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10bbeb: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10bbee: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 10bbf3: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10bbf6: 89 3d bc ca 11 00 mov %edi,0x11cabc <== NOT EXECUTED _Watchdog_Sync_count--; 10bbfc: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bc01: 48 dec %eax <== NOT EXECUTED 10bc02: a3 4c cb 11 00 mov %eax,0x11cb4c <== NOT EXECUTED _ISR_Enable( level ); 10bc07: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bc0a: 9d popf <== NOT EXECUTED } 10bc0b: 58 pop %eax <== NOT EXECUTED 10bc0c: 5b pop %ebx <== NOT EXECUTED 10bc0d: 5e pop %esi <== NOT EXECUTED 10bc0e: 5f pop %edi <== NOT EXECUTED 10bc0f: c9 leave <== NOT EXECUTED 10bc10: c3 ret <== NOT EXECUTED 0010bc74 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10bc74: 55 push %ebp <== NOT EXECUTED 10bc75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc77: 56 push %esi <== NOT EXECUTED 10bc78: 53 push %ebx <== NOT EXECUTED 10bc79: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10bc7c: 9c pushf <== NOT EXECUTED 10bc7d: fa cli <== NOT EXECUTED 10bc7e: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10bc7f: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10bc82: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10bc85: 74 09 je 10bc90 <_Watchdog_Remove+0x1c> <== NOT EXECUTED 10bc87: 72 41 jb 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bc89: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10bc8c: 77 3c ja 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bc8e: eb 09 jmp 10bc99 <_Watchdog_Remove+0x25> <== NOT EXECUTED /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 10bc90: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10bc97: eb 31 jmp 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10bc99: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bca0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10bca2: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10bca5: 74 06 je 10bcad <_Watchdog_Remove+0x39> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10bca7: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10bcaa: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10bcad: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bcb2: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcb4: 74 0a je 10bcc0 <_Watchdog_Remove+0x4c> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10bcb6: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 10bcbb: a3 bc ca 11 00 mov %eax,0x11cabc <== NOT EXECUTED 10bcc0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10bcc2: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10bcc5: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10bcc8: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10bcca: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 10bccf: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bcd2: 56 push %esi <== NOT EXECUTED 10bcd3: 9d popf <== NOT EXECUTED return( previous_state ); } 10bcd4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bcd6: 5b pop %ebx <== NOT EXECUTED 10bcd7: 5e pop %esi <== NOT EXECUTED 10bcd8: c9 leave <== NOT EXECUTED 10bcd9: c3 ret <== NOT EXECUTED 0010bcdc <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10bcdc: 55 push %ebp <== NOT EXECUTED 10bcdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcdf: 57 push %edi <== NOT EXECUTED 10bce0: 56 push %esi <== NOT EXECUTED 10bce1: 53 push %ebx <== NOT EXECUTED 10bce2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bce5: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10bce8: 9c pushf <== NOT EXECUTED 10bce9: fa cli <== NOT EXECUTED 10bcea: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10bceb: 8b 17 mov (%edi),%edx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10bced: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10bcf0: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10bcf3: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bcf5: 74 44 je 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bcf7: 89 d3 mov %edx,%ebx <== NOT EXECUTED * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10bcf9: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bcfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcfe: 74 08 je 10bd08 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED the_watchdog->delta_interval--; 10bd00: 48 dec %eax <== NOT EXECUTED 10bd01: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10bd04: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd06: 75 33 jne 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10bd08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd0b: 53 push %ebx <== NOT EXECUTED 10bd0c: e8 63 ff ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10bd11: 56 push %esi <== NOT EXECUTED 10bd12: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10bd13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd16: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10bd19: 75 0e jne 10bd29 <_Watchdog_Tickle+0x4d> <== NOT EXECUTED case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10bd1b: 50 push %eax <== NOT EXECUTED 10bd1c: 50 push %eax <== NOT EXECUTED 10bd1d: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10bd20: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10bd23: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10bd26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10bd29: 9c pushf <== NOT EXECUTED 10bd2a: fa cli <== NOT EXECUTED 10bd2b: 5e pop %esi <== NOT EXECUTED 10bd2c: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10bd2e: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 10bd31: 74 08 je 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bd33: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bd35: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10bd39: eb cb jmp 10bd06 <_Watchdog_Tickle+0x2a> <== NOT EXECUTED leave: _ISR_Enable(level); 10bd3b: 56 push %esi <== NOT EXECUTED 10bd3c: 9d popf <== NOT EXECUTED } 10bd3d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd40: 5b pop %ebx <== NOT EXECUTED 10bd41: 5e pop %esi <== NOT EXECUTED 10bd42: 5f pop %edi <== NOT EXECUTED 10bd43: c9 leave <== NOT EXECUTED 10bd44: c3 ret <== NOT EXECUTED 0010bd5d <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10bd5d: 55 push %ebp <== NOT EXECUTED 10bd5e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd60: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10bd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd66: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd6b: e8 2c 1b 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED } 10bd70: c9 leave <== NOT EXECUTED 10bd71: c3 ret <== NOT EXECUTED 0010bd72 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10bd72: 55 push %ebp <== NOT EXECUTED 10bd73: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10bd78: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd7b: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd80: e8 17 1b 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10bd85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd88: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd8a: 75 0c jne 10bd98 <_Workspace_Allocate_or_fatal_error+0x26> <== NOT EXECUTED _Internal_error_Occurred( 10bd8c: 50 push %eax <== NOT EXECUTED 10bd8d: 6a 04 push $0x4 <== NOT EXECUTED 10bd8f: 6a 01 push $0x1 <== NOT EXECUTED 10bd91: 6a 00 push $0x0 <== NOT EXECUTED 10bd93: e8 90 e3 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10bd98: c9 leave <== NOT EXECUTED 10bd99: c3 ret <== NOT EXECUTED 0010bd48 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10bd48: 55 push %ebp <== NOT EXECUTED 10bd49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10bd4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd51: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd56: e8 ad 1b 00 00 call 10d908 <_Heap_Free> <== NOT EXECUTED } 10bd5b: c9 leave <== NOT EXECUTED 10bd5c: c3 ret <== NOT EXECUTED 0010bd9a <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10bd9a: 55 push %ebp <== NOT EXECUTED 10bd9b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd9d: 57 push %edi <== NOT EXECUTED 10bd9e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bda1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10bda4: 85 d2 test %edx,%edx <== NOT EXECUTED 10bda6: 74 05 je 10bdad <_Workspace_Handler_initialization+0x13> <== NOT EXECUTED 10bda8: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10bdab: 74 05 je 10bdb2 <_Workspace_Handler_initialization+0x18> <== NOT EXECUTED _Internal_error_Occurred( 10bdad: 51 push %ecx <== NOT EXECUTED 10bdae: 6a 02 push $0x2 <== NOT EXECUTED 10bdb0: eb 2e jmp 10bde0 <_Workspace_Handler_initialization+0x46> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10bdb2: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10bdb7: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10bdbb: 74 09 je 10bdc6 <_Workspace_Handler_initialization+0x2c> <== NOT EXECUTED memset( starting_address, 0, size ); 10bdbd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bdbf: 89 d7 mov %edx,%edi <== NOT EXECUTED 10bdc1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bdc4: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED memory_available = _Heap_Initialize( 10bdc6: 6a 04 push $0x4 <== NOT EXECUTED 10bdc8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bdcb: 52 push %edx <== NOT EXECUTED 10bdcc: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bdd1: e8 8a e1 ff ff call 109f60 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10bdd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdd9: 85 c0 test %eax,%eax <== NOT EXECUTED 10bddb: 75 0c jne 10bde9 <_Workspace_Handler_initialization+0x4f> <== NOT EXECUTED _Internal_error_Occurred( 10bddd: 52 push %edx <== NOT EXECUTED 10bdde: 6a 03 push $0x3 <== NOT EXECUTED 10bde0: 6a 01 push $0x1 <== NOT EXECUTED 10bde2: 6a 00 push $0x0 <== NOT EXECUTED 10bde4: e8 3f e3 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10bde9: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10bdec: c9 leave <== NOT EXECUTED 10bded: c3 ret <== NOT EXECUTED 001062b2 <__assert>: void __assert( const char *file, int line, const char *failedexpr ) { 1062b2: 55 push %ebp <== NOT EXECUTED 1062b3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1062b5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED __assert_func (file, line, NULL, failedexpr); 1062b8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1062bb: 6a 00 push $0x0 <== NOT EXECUTED 1062bd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1062c0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1062c3: e8 b0 ff ff ff call 106278 <__assert_func> <== NOT EXECUTED 1062c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1062cb: c9 leave <== NOT EXECUTED 1062cc: c3 ret <== NOT EXECUTED 00106278 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) { 106278: 55 push %ebp <== NOT EXECUTED 106279: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10627b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10627e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106281: ba 09 67 11 00 mov $0x116709,%edx <== NOT EXECUTED 106286: 85 c0 test %eax,%eax <== NOT EXECUTED 106288: 75 07 jne 106291 <__assert_func+0x19> <== NOT EXECUTED 10628a: ba a1 67 11 00 mov $0x1167a1,%edx <== NOT EXECUTED 10628f: 89 d0 mov %edx,%eax <== NOT EXECUTED 106291: 51 push %ecx <== NOT EXECUTED 106292: 51 push %ecx <== NOT EXECUTED 106293: 50 push %eax <== NOT EXECUTED 106294: 52 push %edx <== NOT EXECUTED 106295: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106298: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10629b: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10629e: 68 16 67 11 00 push $0x116716 <== NOT EXECUTED 1062a3: e8 8a 0d 00 00 call 107032 <== NOT EXECUTED file, line, (func) ? ", function: " : "", (func) ? func : "" ); rtems_fatal_error_occurred(0); 1062a8: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 1062ab: 6a 00 push $0x0 <== NOT EXECUTED 1062ad: e8 ae 34 00 00 call 109760 <== NOT EXECUTED 0011c268 <__env_lock>: 11c268: 55 push %ebp <== NOT EXECUTED 11c269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11c26b: c9 leave <== NOT EXECUTED 11c26c: c3 ret <== NOT EXECUTED 0011c270 <__env_unlock>: 11c270: 55 push %ebp <== NOT EXECUTED 11c271: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11c273: c9 leave <== NOT EXECUTED 11c274: c3 ret <== NOT EXECUTED 0011d56a <__kill>: #endif #endif int __kill( pid_t pid, int sig ) { 11d56a: 55 push %ebp <== NOT EXECUTED 11d56b: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11d56d: 31 c0 xor %eax,%eax <== NOT EXECUTED 11d56f: c9 leave <== NOT EXECUTED 11d570: c3 ret <== NOT EXECUTED 00114aa0 <_calloc_r>: void *_calloc_r( struct _reent *ignored, size_t elements, size_t size ) { 114aa0: 55 push %ebp <== NOT EXECUTED 114aa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114aa3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return calloc( elements, size ); 114aa6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 114aa9: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 114aac: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 114aaf: c9 leave <== NOT EXECUTED struct _reent *ignored, size_t elements, size_t size ) { return calloc( elements, size ); 114ab0: e9 2f 81 ff ff jmp 10cbe4 <== NOT EXECUTED 0010cc95 <_close_r>: int _close_r( struct _reent *ptr, int fd ) { 10cc95: 55 push %ebp <== NOT EXECUTED 10cc96: 89 e5 mov %esp,%ebp <== NOT EXECUTED return close( fd ); 10cc98: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cc9b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cc9e: c9 leave <== NOT EXECUTED int _close_r( struct _reent *ptr, int fd ) { return close( fd ); 10cc9f: e9 7c ff ff ff jmp 10cc20 <== NOT EXECUTED 00114cca <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 114cca: 55 push %ebp <== NOT EXECUTED 114ccb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ccd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cd0: e8 28 07 00 00 call 1153fd <_fini> <== NOT EXECUTED * We need to do the exit processing on the global reentrancy structure. * This has already been done on the per task reentrancy structure * associated with this task. */ libc_wrapup(); 114cd5: e8 8a ff ff ff call 114c64 <== NOT EXECUTED rtems_shutdown_executive(status); 114cda: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114cdd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114ce0: e8 d7 00 00 00 call 114dbc <== NOT EXECUTED 114ce5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114ce8: eb fe jmp 114ce8 <_exit+0x1e> <== NOT EXECUTED 00129402 <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) { 129402: 55 push %ebp <== NOT EXECUTED 129403: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129405: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 129408: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 12940b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 12940e: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 129411: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 129414: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 129417: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 129418: e9 9f fe ff ff jmp 1292bc <== NOT EXECUTED 00114ab8 <_free_r>: void _free_r( struct _reent *ignored, void *ptr ) { 114ab8: 55 push %ebp <== NOT EXECUTED 114ab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED free( ptr ); 114abb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 114abe: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 114ac1: c9 leave <== NOT EXECUTED void _free_r( struct _reent *ignored, void *ptr ) { free( ptr ); 114ac2: e9 a1 19 ff ff jmp 106468 <== NOT EXECUTED 00114b54 <_fstat_r>: int _fstat_r( struct _reent *ptr, int fd, struct stat *buf ) { 114b54: 55 push %ebp <== NOT EXECUTED 114b55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114b57: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return fstat( fd, buf ); 114b5a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 114b5d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 114b60: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 114b63: c9 leave <== NOT EXECUTED struct _reent *ptr, int fd, struct stat *buf ) { return fstat( fd, buf ); 114b64: e9 5f ff ff ff jmp 114ac8 <== NOT EXECUTED 0011d45a <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 11d45a: 55 push %ebp <== NOT EXECUTED 11d45b: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 11d45d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11d462: c9 leave <== NOT EXECUTED 11d463: c3 ret <== NOT EXECUTED 0010cd98 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10cd98: 55 push %ebp <== NOT EXECUTED 10cd99: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10cd9b: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10cd9c: e9 a7 ff ff ff jmp 10cd48 <== NOT EXECUTED 0010cda1 <_gettimeofday_r>: int _gettimeofday_r( struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { 10cda1: 55 push %ebp <== NOT EXECUTED 10cda2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cda4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return gettimeofday( tp, tzp ); 10cda7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10cdaa: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10cdad: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10cdb0: c9 leave <== NOT EXECUTED struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10cdb1: e9 92 ff ff ff jmp 10cd48 <== NOT EXECUTED 0011d563 <_kill_r>: #if defined(RTEMS_NEWLIB) #include int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 11d563: 55 push %ebp <== NOT EXECUTED 11d564: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11d566: 31 c0 xor %eax,%eax <== NOT EXECUTED 11d568: c9 leave <== NOT EXECUTED 11d569: c3 ret <== NOT EXECUTED 0011ffb6 <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) { 11ffb6: 55 push %ebp <== NOT EXECUTED 11ffb7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ffb9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return link( existing, new ); 11ffbc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11ffbf: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11ffc2: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 11ffc5: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 11ffc6: e9 3d fe ff ff jmp 11fe08 <== NOT EXECUTED 00114c39 <_lseek_r>: struct _reent *ptr, int fd, off_t offset, int whence ) { 114c39: 55 push %ebp <== NOT EXECUTED 114c3a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114c3c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 114c3f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return lseek( fd, offset, whence ); 114c42: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 114c45: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 114c48: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 114c4b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 114c4e: c9 leave <== NOT EXECUTED int fd, off_t offset, int whence ) { return lseek( fd, offset, whence ); 114c4f: e9 4c ff ff ff jmp 114ba0 <== NOT EXECUTED 0012011f <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 12011f: 55 push %ebp <== NOT EXECUTED 120120: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120122: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 120125: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 120128: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 12012b: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 12012e: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 12012f: e9 4c ff ff ff jmp 120080 <== NOT EXECUTED 00114c54 <_malloc_r>: void *_malloc_r( struct _reent *ignored, size_t size ) { 114c54: 55 push %ebp <== NOT EXECUTED 114c55: 89 e5 mov %esp,%ebp <== NOT EXECUTED return malloc( size ); 114c57: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 114c5a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 114c5d: c9 leave <== NOT EXECUTED void *_malloc_r( struct _reent *ignored, size_t size ) { return malloc( size ); 114c5e: e9 01 1a ff ff jmp 106664 <== NOT EXECUTED 00106d7d <_open_r>: struct _reent *ptr, const char *buf, int flags, int mode ) { 106d7d: 55 push %ebp <== NOT EXECUTED 106d7e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d80: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106d83: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return open( buf, flags, mode ); 106d86: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 106d89: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 106d8c: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 106d8f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 106d92: c9 leave <== NOT EXECUTED const char *buf, int flags, int mode ) { return open( buf, flags, mode ); 106d93: e9 ec fd ff ff jmp 106b84 <== NOT EXECUTED 00114d6d <_read_r>: struct _reent *ptr, int fd, void *buf, size_t nbytes ) { 114d6d: 55 push %ebp <== NOT EXECUTED 114d6e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114d70: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 114d73: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return read( fd, buf, nbytes ); 114d76: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 114d79: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 114d7c: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 114d7f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 114d82: c9 leave <== NOT EXECUTED int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes ); 114d83: e9 64 ff ff ff jmp 114cec <== NOT EXECUTED 00114d88 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 114d88: 55 push %ebp <== NOT EXECUTED 114d89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114d8b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 114d8e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 114d91: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 114d94: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 114d97: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 114d98: e9 4f 00 00 00 jmp 114dec <== NOT EXECUTED 00138ba8 <_rename_r>: int _rename_r( struct _reent *ptr, const char *old, const char *new ) { 138ba8: 55 push %ebp <== NOT EXECUTED 138ba9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 138bab: 53 push %ebx <== NOT EXECUTED 138bac: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 138baf: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat sb; int s; s = stat( old, &sb); 138bb2: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 138bb5: 50 push %eax <== NOT EXECUTED 138bb6: 53 push %ebx <== NOT EXECUTED 138bb7: e8 d0 27 fd ff call 10b38c <== NOT EXECUTED if ( s < 0 ) 138bbc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 138bbf: 85 c0 test %eax,%eax <== NOT EXECUTED 138bc1: 78 38 js 138bfb <_rename_r+0x53> <== NOT EXECUTED return s; s = link( old, new ); 138bc3: 50 push %eax <== NOT EXECUTED 138bc4: 50 push %eax <== NOT EXECUTED 138bc5: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 138bc8: 53 push %ebx <== NOT EXECUTED 138bc9: e8 3a 72 fe ff call 11fe08 <== NOT EXECUTED if ( s < 0 ) 138bce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 138bd1: 85 c0 test %eax,%eax <== NOT EXECUTED 138bd3: 78 26 js 138bfb <_rename_r+0x53> <== NOT EXECUTED return s; return S_ISDIR(sb.st_mode) ? rmdir( old ) : unlink( old ); 138bd5: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 138bd8: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 138bdd: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 138be2: 75 0b jne 138bef <_rename_r+0x47> <== NOT EXECUTED 138be4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 138be7: 53 push %ebx <== NOT EXECUTED 138be8: e8 6f 7a fe ff call 12065c <== NOT EXECUTED 138bed: eb 09 jmp 138bf8 <_rename_r+0x50> <== NOT EXECUTED 138bef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 138bf2: 53 push %ebx <== NOT EXECUTED 138bf3: e8 54 41 fd ff call 10cd4c <== NOT EXECUTED 138bf8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 138bfb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 138bfe: c9 leave <== NOT EXECUTED 138bff: c3 ret <== NOT EXECUTED 0010b42b <_stat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 10b42b: 55 push %ebp <== NOT EXECUTED 10b42c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b42e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 10b431: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b434: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10b437: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10b43a: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 10b43b: e9 4c ff ff ff jmp 10b38c <== NOT EXECUTED 0010ce54 <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) { 10ce54: 55 push %ebp <== NOT EXECUTED 10ce55: 89 e5 mov %esp,%ebp <== NOT EXECUTED return unlink( path ); 10ce57: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ce5a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ce5d: c9 leave <== NOT EXECUTED int _unlink_r( struct _reent *ptr, const char *path ) { return unlink( path ); 10ce5e: e9 e9 fe ff ff jmp 10cd4c <== NOT EXECUTED 00114da0 <_write_r>: struct _reent *ptr, int fd, const void *buf, size_t nbytes ) { 114da0: 55 push %ebp <== NOT EXECUTED 114da1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114da3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 114da6: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return write( fd, buf, nbytes ); 114da9: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 114dac: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 114daf: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 114db2: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 114db5: c9 leave <== NOT EXECUTED int fd, const void *buf, size_t nbytes ) { return write( fd, buf, nbytes ); 114db6: e9 25 01 00 00 jmp 114ee0 <== NOT EXECUTED 0011e928 : int access( const char *path, int amode ) { 11e928: 55 push %ebp <== NOT EXECUTED 11e929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e92b: 53 push %ebx <== NOT EXECUTED 11e92c: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 11e92f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat statbuf; if ( stat(path, &statbuf) ) 11e932: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 11e935: 50 push %eax <== NOT EXECUTED 11e936: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11e939: e8 4e ca fe ff call 10b38c <== NOT EXECUTED 11e93e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e941: 85 c0 test %eax,%eax <== NOT EXECUTED 11e943: 75 21 jne 11e966 <== NOT EXECUTED return -1; if ( amode & R_OK ) { 11e945: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 11e948: 74 06 je 11e950 <== NOT EXECUTED if (!( statbuf.st_mode & S_IREAD )) 11e94a: f6 45 bd 01 testb $0x1,-0x43(%ebp) <== NOT EXECUTED 11e94e: 74 16 je 11e966 <== NOT EXECUTED return -1; } if ( amode & W_OK ) { 11e950: f6 c3 02 test $0x2,%bl <== NOT EXECUTED 11e953: 74 06 je 11e95b <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) 11e955: 80 7d bc 00 cmpb $0x0,-0x44(%ebp) <== NOT EXECUTED 11e959: 79 0b jns 11e966 <== NOT EXECUTED return -1; } if ( amode & X_OK ) { 11e95b: 80 e3 01 and $0x1,%bl <== NOT EXECUTED 11e95e: 74 0b je 11e96b <== NOT EXECUTED if ( !( statbuf.st_mode & S_IEXEC ) ) 11e960: f6 45 bc 40 testb $0x40,-0x44(%ebp) <== NOT EXECUTED 11e964: 75 05 jne 11e96b <== NOT EXECUTED 11e966: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11e969: eb 02 jmp 11e96d <== NOT EXECUTED 11e96b: 31 c0 xor %eax,%eax <== NOT EXECUTED return -1; } return 0; } 11e96d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11e970: c9 leave <== NOT EXECUTED 11e971: c3 ret <== NOT EXECUTED 0010cbe4 : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10cbe4: 55 push %ebp <== NOT EXECUTED 10cbe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cbe7: 57 push %edi <== NOT EXECUTED 10cbe8: 53 push %ebx <== NOT EXECUTED 10cbe9: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cbec: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10cbef: ff 05 24 c9 11 00 incl 0x11c924 <== NOT EXECUTED length = nelem * elsize; 10cbf5: 0f af 5d 08 imul 0x8(%ebp),%ebx <== NOT EXECUTED cptr = malloc( length ); 10cbf9: 53 push %ebx <== NOT EXECUTED 10cbfa: e8 65 9a ff ff call 106664 <== NOT EXECUTED 10cbff: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( cptr ) 10cc01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cc04: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc06: 74 08 je 10cc10 <== NOT EXECUTED memset( cptr, '\0', length ); 10cc08: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cc0a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cc0c: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10cc0e: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10cc10: ff 0d 14 c9 11 00 decl 0x11c914 <== NOT EXECUTED return cptr; } 10cc16: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc18: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cc1b: 5b pop %ebx <== NOT EXECUTED 10cc1c: 5f pop %edi <== NOT EXECUTED 10cc1d: c9 leave <== NOT EXECUTED 10cc1e: c3 ret <== NOT EXECUTED 0011eb04 : #include int chdir( const char *pathname ) { 11eb04: 55 push %ebp <== NOT EXECUTED 11eb05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11eb07: 57 push %edi <== NOT EXECUTED 11eb08: 56 push %esi <== NOT EXECUTED 11eb09: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 11eb0c: 6a 01 push $0x1 <== NOT EXECUTED 11eb0e: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 11eb11: 56 push %esi <== NOT EXECUTED 11eb12: 6a 01 push $0x1 <== NOT EXECUTED 11eb14: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11eb17: e8 de b3 fe ff call 109efa <== NOT EXECUTED pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 11eb1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11eb1f: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11eb22: 85 c0 test %eax,%eax <== NOT EXECUTED 11eb24: 0f 85 8d 00 00 00 jne 11ebb7 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 11eb2a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11eb2d: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 11eb30: 85 d2 test %edx,%edx <== NOT EXECUTED 11eb32: 75 1d jne 11eb51 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11eb34: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11eb37: 85 c0 test %eax,%eax <== NOT EXECUTED 11eb39: 74 09 je 11eb44 <== NOT EXECUTED 11eb3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11eb3e: 56 push %esi <== NOT EXECUTED 11eb3f: ff d0 call *%eax <== NOT EXECUTED 11eb41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11eb44: e8 57 bf 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11eb49: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11eb4f: eb 2e jmp 11eb7f <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 11eb51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11eb54: 56 push %esi <== NOT EXECUTED 11eb55: ff d2 call *%edx <== NOT EXECUTED 11eb57: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11eb5a: 48 dec %eax <== NOT EXECUTED 11eb5b: 74 27 je 11eb84 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11eb5d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11eb60: 85 c0 test %eax,%eax <== NOT EXECUTED 11eb62: 74 10 je 11eb74 <== NOT EXECUTED 11eb64: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11eb67: 85 c0 test %eax,%eax <== NOT EXECUTED 11eb69: 74 09 je 11eb74 <== NOT EXECUTED 11eb6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11eb6e: 56 push %esi <== NOT EXECUTED 11eb6f: ff d0 call *%eax <== NOT EXECUTED 11eb71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 11eb74: e8 27 bf 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11eb79: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 11eb7f: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11eb82: eb 33 jmp 11ebb7 <== NOT EXECUTED } rtems_filesystem_freenode( &rtems_filesystem_current ); 11eb84: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11eb89: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 11eb8c: 85 d2 test %edx,%edx <== NOT EXECUTED 11eb8e: 74 13 je 11eba3 <== NOT EXECUTED 11eb90: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 11eb93: 85 d2 test %edx,%edx <== NOT EXECUTED 11eb95: 74 0c je 11eba3 <== NOT EXECUTED 11eb97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11eb9a: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 11eb9d: 50 push %eax <== NOT EXECUTED 11eb9e: ff d2 call *%edx <== NOT EXECUTED 11eba0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 11eba3: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11eba8: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 11ebab: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 11ebae: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11ebb3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11ebb5: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 11ebb7: 89 d0 mov %edx,%eax <== NOT EXECUTED 11ebb9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11ebbc: 5e pop %esi <== NOT EXECUTED 11ebbd: 5f pop %edi <== NOT EXECUTED 11ebbe: c9 leave <== NOT EXECUTED 11ebbf: c3 ret <== NOT EXECUTED 00109d58 : int chmod( const char *path, mode_t mode ) { 109d58: 55 push %ebp <== NOT EXECUTED 109d59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d5b: 56 push %esi <== NOT EXECUTED 109d5c: 53 push %ebx <== NOT EXECUTED 109d5d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED int status; rtems_filesystem_location_info_t loc; int result; status = rtems_filesystem_evaluate_path( path, 0, &loc, true ); 109d60: 6a 01 push $0x1 <== NOT EXECUTED 109d62: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 109d65: 56 push %esi <== NOT EXECUTED 109d66: 6a 00 push $0x0 <== NOT EXECUTED 109d68: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d6b: e8 8a 01 00 00 call 109efa <== NOT EXECUTED if ( status != 0 ) 109d70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d73: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 109d76: 85 c0 test %eax,%eax <== NOT EXECUTED 109d78: 75 7d jne 109df7 <== NOT EXECUTED return -1; if ( !loc.handlers ){ 109d7a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109d7d: 85 c0 test %eax,%eax <== NOT EXECUTED 109d7f: 75 24 jne 109da5 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 109d81: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 109d84: 85 c0 test %eax,%eax <== NOT EXECUTED 109d86: 74 10 je 109d98 <== NOT EXECUTED 109d88: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109d8b: 85 c0 test %eax,%eax <== NOT EXECUTED 109d8d: 74 09 je 109d98 <== NOT EXECUTED 109d8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d92: 56 push %esi <== NOT EXECUTED 109d93: ff d0 call *%eax <== NOT EXECUTED 109d95: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 109d98: e8 03 0d 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109d9d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 109da3: eb 29 jmp 109dce <== NOT EXECUTED } if ( !loc.handlers->fchmod_h ){ 109da5: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109da8: 85 c0 test %eax,%eax <== NOT EXECUTED 109daa: 75 27 jne 109dd3 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 109dac: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 109daf: 85 c0 test %eax,%eax <== NOT EXECUTED 109db1: 74 10 je 109dc3 <== NOT EXECUTED 109db3: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109db6: 85 c0 test %eax,%eax <== NOT EXECUTED 109db8: 74 09 je 109dc3 <== NOT EXECUTED 109dba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109dbd: 56 push %esi <== NOT EXECUTED 109dbe: ff d0 call *%eax <== NOT EXECUTED 109dc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 109dc3: e8 d8 0c 02 00 call 12aaa0 <__errno> <== NOT EXECUTED 109dc8: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 109dce: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 109dd1: eb 24 jmp 109df7 <== NOT EXECUTED } result = (*loc.handlers->fchmod_h)( &loc, mode ); 109dd3: 52 push %edx <== NOT EXECUTED 109dd4: 52 push %edx <== NOT EXECUTED 109dd5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109dd8: 56 push %esi <== NOT EXECUTED 109dd9: ff d0 call *%eax <== NOT EXECUTED 109ddb: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 109ddd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 109de0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109de3: 85 c0 test %eax,%eax <== NOT EXECUTED 109de5: 74 10 je 109df7 <== NOT EXECUTED 109de7: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109dea: 85 c0 test %eax,%eax <== NOT EXECUTED 109dec: 74 09 je 109df7 <== NOT EXECUTED 109dee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109df1: 56 push %esi <== NOT EXECUTED 109df2: ff d0 call *%eax <== NOT EXECUTED 109df4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 109df7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109df9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109dfc: 5b pop %ebx <== NOT EXECUTED 109dfd: 5e pop %esi <== NOT EXECUTED 109dfe: c9 leave <== NOT EXECUTED 109dff: c3 ret <== NOT EXECUTED 0011ebc0 : int chown( const char *path, uid_t owner, gid_t group ) { 11ebc0: 55 push %ebp <== NOT EXECUTED 11ebc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ebc3: 57 push %edi <== NOT EXECUTED 11ebc4: 56 push %esi <== NOT EXECUTED 11ebc5: 53 push %ebx <== NOT EXECUTED 11ebc6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11ebc9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11ebcc: 66 89 45 e2 mov %ax,-0x1e(%ebp) <== NOT EXECUTED 11ebd0: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) ) 11ebd3: 6a 01 push $0x1 <== NOT EXECUTED 11ebd5: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 11ebd8: 56 push %esi <== NOT EXECUTED 11ebd9: 6a 00 push $0x0 <== NOT EXECUTED 11ebdb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11ebde: e8 17 b3 fe ff call 109efa <== NOT EXECUTED 11ebe3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ebe6: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11ebe9: 85 c0 test %eax,%eax <== NOT EXECUTED 11ebeb: 75 53 jne 11ec40 <== NOT EXECUTED return -1; if ( !loc.ops->chown_h ) { 11ebed: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11ebf0: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 11ebf3: 85 d2 test %edx,%edx <== NOT EXECUTED 11ebf5: 75 20 jne 11ec17 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ebf7: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ebfa: 85 c0 test %eax,%eax <== NOT EXECUTED 11ebfc: 74 09 je 11ec07 <== NOT EXECUTED 11ebfe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec01: 56 push %esi <== NOT EXECUTED 11ec02: ff d0 call *%eax <== NOT EXECUTED 11ec04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ec07: e8 94 be 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ec0c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ec12: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11ec15: eb 29 jmp 11ec40 <== NOT EXECUTED } result = (*loc.ops->chown_h)( &loc, owner, group ); 11ec17: 50 push %eax <== NOT EXECUTED 11ec18: 0f b7 c7 movzwl %di,%eax <== NOT EXECUTED 11ec1b: 50 push %eax <== NOT EXECUTED 11ec1c: 0f b7 45 e2 movzwl -0x1e(%ebp),%eax <== NOT EXECUTED 11ec20: 50 push %eax <== NOT EXECUTED 11ec21: 56 push %esi <== NOT EXECUTED 11ec22: ff d2 call *%edx <== NOT EXECUTED 11ec24: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ec26: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11ec29: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ec2c: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec2e: 74 10 je 11ec40 <== NOT EXECUTED 11ec30: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ec33: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec35: 74 09 je 11ec40 <== NOT EXECUTED 11ec37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec3a: 56 push %esi <== NOT EXECUTED 11ec3b: ff d0 call *%eax <== NOT EXECUTED 11ec3d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 11ec40: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11ec42: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11ec45: 5b pop %ebx <== NOT EXECUTED 11ec46: 5e pop %esi <== NOT EXECUTED 11ec47: 5f pop %edi <== NOT EXECUTED 11ec48: c9 leave <== NOT EXECUTED 11ec49: c3 ret <== NOT EXECUTED 0011ec4c : #include int chroot( const char *pathname ) { 11ec4c: 55 push %ebp <== NOT EXECUTED 11ec4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ec4f: 57 push %edi <== NOT EXECUTED 11ec50: 56 push %esi <== NOT EXECUTED 11ec51: 53 push %ebx <== NOT EXECUTED 11ec52: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED int result; rtems_filesystem_location_info_t loc; /* an automatic call to new private env the first time */ if (rtems_current_user_env == &rtems_global_user_env) { 11ec55: 81 3d 84 3b 14 00 84 cmpl $0x159f84,0x143b84 <== NOT EXECUTED 11ec5c: 9f 15 00 <== NOT EXECUTED 11ec5f: 75 1e jne 11ec7f <== NOT EXECUTED rtems_libio_set_private_env(); /* try to set a new private env*/ 11ec61: e8 b3 17 00 00 call 120419 <== NOT EXECUTED if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 11ec66: 81 3d 84 3b 14 00 84 cmpl $0x159f84,0x143b84 <== NOT EXECUTED 11ec6d: 9f 15 00 <== NOT EXECUTED 11ec70: 75 0d jne 11ec7f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ec72: e8 29 be 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ec77: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ec7d: eb 22 jmp 11eca1 <== NOT EXECUTED } result = chdir(pathname); 11ec7f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec82: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11ec85: e8 7a fe ff ff call 11eb04 <== NOT EXECUTED if (result) { 11ec8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ec8d: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec8f: 74 15 je 11eca6 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( errno ); 11ec91: e8 0a be 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ec96: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11ec98: e8 03 be 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ec9d: 8b 00 mov (%eax),%eax <== NOT EXECUTED 11ec9f: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11eca1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11eca4: eb 4c jmp 11ecf2 <== NOT EXECUTED } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 11eca6: 6a 00 push $0x0 <== NOT EXECUTED 11eca8: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 11ecab: 50 push %eax <== NOT EXECUTED 11ecac: 6a 00 push $0x0 <== NOT EXECUTED 11ecae: 68 8f b1 13 00 push $0x13b18f <== NOT EXECUTED 11ecb3: e8 42 b2 fe ff call 109efa <== NOT EXECUTED 11ecb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ecbb: 85 c0 test %eax,%eax <== NOT EXECUTED 11ecbd: 75 d2 jne 11ec91 <== NOT EXECUTED /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); } rtems_filesystem_freenode(&rtems_filesystem_root); 11ecbf: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11ecc4: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ecc7: 85 d2 test %edx,%edx <== NOT EXECUTED 11ecc9: 74 13 je 11ecde <== NOT EXECUTED 11eccb: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 11ecce: 85 d2 test %edx,%edx <== NOT EXECUTED 11ecd0: 74 0c je 11ecde <== NOT EXECUTED 11ecd2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ecd5: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11ecd8: 50 push %eax <== NOT EXECUTED 11ecd9: ff d2 call *%edx <== NOT EXECUTED 11ecdb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_root = loc; 11ecde: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11ece3: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 11ece6: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 11ece9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11ecee: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11ecf0: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11ecf2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11ecf5: 5b pop %ebx <== NOT EXECUTED 11ecf6: 5e pop %esi <== NOT EXECUTED 11ecf7: 5f pop %edi <== NOT EXECUTED 11ecf8: c9 leave <== NOT EXECUTED 11ecf9: c3 ret <== NOT EXECUTED 0010cc20 : #include int close( int fd ) { 10cc20: 55 push %ebp <== NOT EXECUTED 10cc21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc23: 56 push %esi <== NOT EXECUTED 10cc24: 53 push %ebx <== NOT EXECUTED 10cc25: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10cc28: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 10cc2e: 73 0f jae 10cc3f <== NOT EXECUTED iop = rtems_libio_iop(fd); 10cc30: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 10cc33: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10cc39: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10cc3d: 75 10 jne 10cc4f <== NOT EXECUTED 10cc3f: e8 6c 1a 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cc44: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10cc4a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cc4d: eb 3f jmp 10cc8e <== NOT EXECUTED rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10cc4f: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10cc52: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cc55: 31 f6 xor %esi,%esi <== NOT EXECUTED 10cc57: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc59: 74 0b je 10cc66 <== NOT EXECUTED rc = (*iop->handlers->close_h)( iop ); 10cc5b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc5e: 53 push %ebx <== NOT EXECUTED 10cc5f: ff d0 call *%eax <== NOT EXECUTED 10cc61: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cc63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &iop->pathinfo ); 10cc66: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10cc69: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc6b: 74 13 je 10cc80 <== NOT EXECUTED 10cc6d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10cc70: 85 d2 test %edx,%edx <== NOT EXECUTED 10cc72: 74 0c je 10cc80 <== NOT EXECUTED 10cc74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc77: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cc7a: 50 push %eax <== NOT EXECUTED 10cc7b: ff d2 call *%edx <== NOT EXECUTED 10cc7d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_libio_free( iop ); 10cc80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc83: 53 push %ebx <== NOT EXECUTED 10cc84: e8 27 02 00 00 call 10ceb0 <== NOT EXECUTED return rc; 10cc89: 89 f0 mov %esi,%eax <== NOT EXECUTED 10cc8b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cc8e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cc91: 5b pop %ebx <== NOT EXECUTED 10cc92: 5e pop %esi <== NOT EXECUTED 10cc93: c9 leave <== NOT EXECUTED 10cc94: c3 ret <== NOT EXECUTED 00129168 : * close a directory. */ int closedir( DIR *dirp ) { 129168: 55 push %ebp <== NOT EXECUTED 129169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12916b: 56 push %esi <== NOT EXECUTED 12916c: 53 push %ebx <== NOT EXECUTED 12916d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED int fd; if ( !dirp ) 129170: 85 f6 test %esi,%esi <== NOT EXECUTED 129172: 75 15 jne 129189 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 129174: e8 27 19 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 129179: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); } 12917f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129182: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129185: 5b pop %ebx <== NOT EXECUTED 129186: 5e pop %esi <== NOT EXECUTED 129187: c9 leave <== NOT EXECUTED 129188: c3 ret <== NOT EXECUTED int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 129189: 8b 1e mov (%esi),%ebx <== NOT EXECUTED dirp->dd_fd = -1; 12918b: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED dirp->dd_loc = 0; 129191: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED (void)free((void *)dirp->dd_buf); 129198: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12919b: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 12919e: e8 79 0e fe ff call 10a01c <== NOT EXECUTED (void)free((void *)dirp); 1291a3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1291a6: e8 71 0e fe ff call 10a01c <== NOT EXECUTED return(close(fd)); 1291ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1291ae: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 1291b1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1291b4: 5b pop %ebx <== NOT EXECUTED 1291b5: 5e pop %esi <== NOT EXECUTED 1291b6: c9 leave <== NOT EXECUTED fd = dirp->dd_fd; dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); 1291b7: e9 44 0c fe ff jmp 109e00 <== NOT EXECUTED 0010dfaa : */ int device_close( rtems_libio_t *iop ) { 10dfaa: 55 push %ebp <== NOT EXECUTED 10dfab: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfad: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10dfb0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10dfb3: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10dfb6: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = 0; 10dfb9: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) <== NOT EXECUTED args.mode = 0; 10dfc0: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_close( 10dfc7: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10dfca: 50 push %eax <== NOT EXECUTED 10dfcb: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10dfce: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10dfd1: e8 d2 03 00 00 call 10e3a8 <== NOT EXECUTED 10dfd6: 89 c2 mov %eax,%edx <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10dfd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dfdb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dfdd: 85 d2 test %edx,%edx <== NOT EXECUTED 10dfdf: 74 07 je 10dfe8 <== NOT EXECUTED return rtems_deviceio_errno(status); 10dfe1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dfe3: e8 bb fe ff ff call 10dea3 <== NOT EXECUTED } return 0; } 10dfe8: c9 leave <== NOT EXECUTED 10dfe9: c3 ret <== NOT EXECUTED 0010de9c : int device_ftruncate( rtems_libio_t *iop, off_t length ) { 10de9c: 55 push %ebp <== NOT EXECUTED 10de9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10de9f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dea1: c9 leave <== NOT EXECUTED 10dea2: c3 ret <== NOT EXECUTED 0010decd : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10decd: 55 push %ebp <== NOT EXECUTED 10dece: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ded0: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ded3: 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; 10ded6: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 10ded9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dedc: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 10dedf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dee2: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 10dee5: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 10dee8: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10deeb: 50 push %eax <== NOT EXECUTED 10deec: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10deef: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10def2: e8 f1 04 00 00 call 10e3e8 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10def7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10defa: 85 c0 test %eax,%eax <== NOT EXECUTED 10defc: 74 07 je 10df05 <== NOT EXECUTED return rtems_deviceio_errno(status); 10defe: e8 a0 ff ff ff call 10dea3 <== NOT EXECUTED 10df03: eb 03 jmp 10df08 <== NOT EXECUTED return args.ioctl_return; 10df05: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10df08: c9 leave <== NOT EXECUTED 10df09: c3 ret <== NOT EXECUTED 0010de94 : off_t device_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10de94: 55 push %ebp <== NOT EXECUTED 10de95: 89 e5 mov %esp,%ebp <== NOT EXECUTED return offset; } 10de97: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de9a: c9 leave <== NOT EXECUTED 10de9b: c3 ret <== NOT EXECUTED 0010dfea : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10dfea: 55 push %ebp <== NOT EXECUTED 10dfeb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfed: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10dff0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10dff3: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10dff6: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10dff9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10dffc: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.mode = mode; 10dfff: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10e002: 89 45 fc mov %eax,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_open( 10e005: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10e008: 50 push %eax <== NOT EXECUTED 10e009: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10e00c: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10e00f: e8 14 04 00 00 call 10e428 <== NOT EXECUTED 10e014: 89 c2 mov %eax,%edx <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e016: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e019: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e01b: 85 d2 test %edx,%edx <== NOT EXECUTED 10e01d: 74 07 je 10e026 <== NOT EXECUTED return rtems_deviceio_errno(status); 10e01f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e021: e8 7d fe ff ff call 10dea3 <== NOT EXECUTED return 0; } 10e026: c9 leave <== NOT EXECUTED 10e027: c3 ret <== NOT EXECUTED 0010df5a : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10df5a: 55 push %ebp <== NOT EXECUTED 10df5b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df5d: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10df60: 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; 10df63: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10df66: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10df69: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10df6c: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 10df6f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df72: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10df75: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10df78: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10df7b: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10df7e: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10df81: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 10df88: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10df8b: 50 push %eax <== NOT EXECUTED 10df8c: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10df8f: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10df92: e8 d1 04 00 00 call 10e468 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10df97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df9a: 85 c0 test %eax,%eax <== NOT EXECUTED 10df9c: 74 07 je 10dfa5 <== NOT EXECUTED return rtems_deviceio_errno(status); 10df9e: e8 00 ff ff ff call 10dea3 <== NOT EXECUTED 10dfa3: eb 03 jmp 10dfa8 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10dfa5: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10dfa8: c9 leave <== NOT EXECUTED 10dfa9: c3 ret <== NOT EXECUTED 0010df0a : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10df0a: 55 push %ebp <== NOT EXECUTED 10df0b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df0d: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10df10: 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; 10df13: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10df16: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10df19: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10df1c: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = (void *) buffer; 10df1f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df22: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10df25: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10df28: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10df2b: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10df2e: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10df31: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_write( 10df38: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10df3b: 50 push %eax <== NOT EXECUTED 10df3c: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10df3f: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10df42: e8 61 05 00 00 call 10e4a8 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10df47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df4a: 85 c0 test %eax,%eax <== NOT EXECUTED 10df4c: 74 07 je 10df55 <== NOT EXECUTED return rtems_deviceio_errno(status); 10df4e: e8 50 ff ff ff call 10dea3 <== NOT EXECUTED 10df53: eb 03 jmp 10df58 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10df55: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10df58: c9 leave <== NOT EXECUTED 10df59: c3 ret <== NOT EXECUTED 00107c56 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 107c56: 55 push %ebp <== NOT EXECUTED 107c57: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107c59: 53 push %ebx <== NOT EXECUTED 107c5a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 107c5d: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 107c5f: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax) <== NOT EXECUTED 107c66: 74 46 je 107cae <== NOT EXECUTED rtems_interrupt_disable (level); 107c68: 9c pushf <== NOT EXECUTED 107c69: fa cli <== NOT EXECUTED 107c6a: 59 pop %ecx <== NOT EXECUTED 107c6b: eb 2f jmp 107c9c <== NOT EXECUTED while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { tty->rawOutBufState = rob_wait; 107c6d: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) <== NOT EXECUTED 107c74: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable (level); 107c77: 51 push %ecx <== NOT EXECUTED 107c78: 9d popf <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 107c79: 51 push %ecx <== NOT EXECUTED 107c7a: 6a 00 push $0x0 <== NOT EXECUTED 107c7c: 6a 00 push $0x0 <== NOT EXECUTED 107c7e: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 107c84: e8 bf 14 00 00 call 109148 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 107c89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c8c: 85 c0 test %eax,%eax <== NOT EXECUTED 107c8e: 74 09 je 107c99 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 107c90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c93: 50 push %eax <== NOT EXECUTED 107c94: e8 c7 1a 00 00 call 109760 <== NOT EXECUTED rtems_interrupt_disable (level); 107c99: 9c pushf <== NOT EXECUTED 107c9a: fa cli <== NOT EXECUTED 107c9b: 59 pop %ecx <== NOT EXECUTED rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 107c9c: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 107ca2: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 107ca8: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107caa: 75 c1 jne 107c6d <== NOT EXECUTED RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 107cac: 51 push %ecx <== NOT EXECUTED 107cad: 9d popf <== NOT EXECUTED } } 107cae: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107cb1: c9 leave <== NOT EXECUTED 107cb2: c3 ret <== NOT EXECUTED 0010788b : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 10788b: 55 push %ebp <== NOT EXECUTED 10788c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10788e: 53 push %ebx <== NOT EXECUTED 10788f: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 107892: 89 d3 mov %edx,%ebx <== NOT EXECUTED 107894: 88 c1 mov %al,%cl <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 107896: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED 10789a: 74 38 je 1078d4 <== NOT EXECUTED 10789c: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 10789f: a1 b8 a9 11 00 mov 0x11a9b8,%eax <== NOT EXECUTED 1078a4: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED 1078a8: 74 2a je 1078d4 <== NOT EXECUTED 1078aa: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED 1078ad: 74 25 je 1078d4 <== NOT EXECUTED 1078af: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 1078b2: 74 20 je 1078d4 <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 1078b4: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED echobuf[1] = c ^ 0x40; 1078b8: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED 1078bb: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED rtems_termios_puts (echobuf, 2, tty); 1078be: 50 push %eax <== NOT EXECUTED 1078bf: 53 push %ebx <== NOT EXECUTED 1078c0: 6a 02 push $0x2 <== NOT EXECUTED 1078c2: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED 1078c5: 50 push %eax <== NOT EXECUTED 1078c6: e8 9c fd ff ff call 107667 <== NOT EXECUTED tty->column += 2; 1078cb: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED 1078cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1078d2: eb 0a jmp 1078de <== NOT EXECUTED } else { oproc (c, tty); 1078d4: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 1078d7: 89 da mov %ebx,%edx <== NOT EXECUTED 1078d9: e8 9e fe ff ff call 10777c <== NOT EXECUTED } } 1078de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1078e1: c9 leave <== NOT EXECUTED 1078e2: c3 ret <== NOT EXECUTED 0011f598 : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 11f598: 55 push %ebp <== NOT EXECUTED 11f599: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f59b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 11f59e: a1 d4 91 15 00 mov 0x1591d4,%eax <== NOT EXECUTED 11f5a3: 85 c0 test %eax,%eax <== NOT EXECUTED 11f5a5: 74 0c je 11f5b3 <== NOT EXECUTED fclose(group_fp); 11f5a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f5aa: 50 push %eax <== NOT EXECUTED 11f5ab: e8 3c b6 00 00 call 12abec <== NOT EXECUTED 11f5b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11f5b3: c9 leave <== NOT EXECUTED 11f5b4: c3 ret <== NOT EXECUTED 0011f5b5 : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 11f5b5: 55 push %ebp <== NOT EXECUTED 11f5b6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f5b8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 11f5bb: a1 ec 90 15 00 mov 0x1590ec,%eax <== NOT EXECUTED 11f5c0: 85 c0 test %eax,%eax <== NOT EXECUTED 11f5c2: 74 0c je 11f5d0 <== NOT EXECUTED fclose(passwd_fp); 11f5c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f5c7: 50 push %eax <== NOT EXECUTED 11f5c8: e8 1f b6 00 00 call 12abec <== NOT EXECUTED 11f5cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11f5d0: c9 leave <== NOT EXECUTED 11f5d1: c3 ret <== NOT EXECUTED 001078e3 : * 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) { 1078e3: 55 push %ebp <== NOT EXECUTED 1078e4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1078e6: 57 push %edi <== NOT EXECUTED 1078e7: 56 push %esi <== NOT EXECUTED 1078e8: 53 push %ebx <== NOT EXECUTED 1078e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1078ec: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1078ee: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED if (tty->ccount == 0) 1078f1: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 1078f5: 0f 84 4d 01 00 00 je 107a48 <== NOT EXECUTED return; if (lineFlag) { 1078fb: 85 d2 test %edx,%edx <== NOT EXECUTED 1078fd: 0f 84 3a 01 00 00 je 107a3d <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { 107903: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED 107906: a8 08 test $0x8,%al <== NOT EXECUTED 107908: 75 0c jne 107916 <== NOT EXECUTED tty->ccount = 0; 10790a: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 107911: e9 32 01 00 00 jmp 107a48 <== NOT EXECUTED return; } if (!(tty->termios.c_lflag & ECHOE)) { 107916: a8 10 test $0x10,%al <== NOT EXECUTED 107918: 0f 85 1f 01 00 00 jne 107a3d <== NOT EXECUTED tty->ccount = 0; 10791e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 107925: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 107929: 89 da mov %ebx,%edx <== NOT EXECUTED 10792b: e8 5b ff ff ff call 10788b <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 107930: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 107934: 0f 84 0e 01 00 00 je 107a48 <== NOT EXECUTED echo ('\n', tty); 10793a: 89 da mov %ebx,%edx <== NOT EXECUTED 10793c: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 107941: eb 28 jmp 10796b <== NOT EXECUTED return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 107943: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 107946: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 107949: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 10794c: 8a 54 0a ff mov -0x1(%edx,%ecx,1),%dl <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 107950: 8b 43 3c mov 0x3c(%ebx),%eax <== NOT EXECUTED 107953: a8 08 test $0x8,%al <== NOT EXECUTED 107955: 0f 84 dc 00 00 00 je 107a37 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 10795b: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10795f: 75 16 jne 107977 <== NOT EXECUTED 107961: a8 10 test $0x10,%al <== NOT EXECUTED 107963: 75 12 jne 107977 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 107965: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 107969: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 10796b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10796e: 5b pop %ebx <== NOT EXECUTED 10796f: 5e pop %esi <== NOT EXECUTED 107970: 5f pop %edi <== NOT EXECUTED 107971: 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); 107972: e9 14 ff ff ff jmp 10788b <== NOT EXECUTED } else if (c == '\t') { 107977: 80 fa 09 cmp $0x9,%dl <== NOT EXECUTED 10797a: 8b 3d b8 a9 11 00 mov 0x11a9b8,%edi <== NOT EXECUTED 107980: 75 5e jne 1079e0 <== NOT EXECUTED int col = tty->read_start_column; 107982: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 107985: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 10798a: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10798f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 107992: eb 2b jmp 1079bf <== NOT EXECUTED /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; 107994: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 107997: 8a 44 10 ff mov -0x1(%eax,%edx,1),%al <== NOT EXECUTED if (c == '\t') { 10799b: 3c 09 cmp $0x9,%al <== NOT EXECUTED 10799d: 75 0a jne 1079a9 <== NOT EXECUTED col = (col | 7) + 1; 10799f: 89 f0 mov %esi,%eax <== NOT EXECUTED 1079a1: 83 c8 07 or $0x7,%eax <== NOT EXECUTED 1079a4: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED 1079a7: eb 15 jmp 1079be <== NOT EXECUTED } else if (iscntrl (c)) { 1079a9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1079ac: f6 04 07 20 testb $0x20,(%edi,%eax,1) <== NOT EXECUTED 1079b0: 74 0b je 1079bd <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 1079b2: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 1079b6: 74 06 je 1079be <== NOT EXECUTED col += 2; 1079b8: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 1079bb: eb 01 jmp 1079be <== NOT EXECUTED } else { col++; 1079bd: 46 inc %esi <== NOT EXECUTED 1079be: 42 inc %edx <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 1079bf: 39 ca cmp %ecx,%edx <== NOT EXECUTED 1079c1: 75 d1 jne 107994 <== NOT EXECUTED 1079c3: eb 14 jmp 1079d9 <== NOT EXECUTED /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 1079c5: 50 push %eax <== NOT EXECUTED 1079c6: 53 push %ebx <== NOT EXECUTED 1079c7: 6a 01 push $0x1 <== NOT EXECUTED 1079c9: 68 a0 67 11 00 push $0x1167a0 <== NOT EXECUTED 1079ce: e8 94 fc ff ff call 107667 <== NOT EXECUTED tty->column--; 1079d3: ff 4b 28 decl 0x28(%ebx) <== NOT EXECUTED 1079d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 1079d9: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED 1079dc: 7f e7 jg 1079c5 <== NOT EXECUTED 1079de: eb 57 jmp 107a37 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 1079e0: 0f b6 f2 movzbl %dl,%esi <== NOT EXECUTED 1079e3: f6 04 37 20 testb $0x20,(%edi,%esi,1) <== NOT EXECUTED 1079e7: 74 21 je 107a0a <== NOT EXECUTED 1079e9: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1079ec: 74 1c je 107a0a <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 1079ee: 50 push %eax <== NOT EXECUTED 1079ef: 53 push %ebx <== NOT EXECUTED 1079f0: 6a 03 push $0x3 <== NOT EXECUTED 1079f2: 68 9e 67 11 00 push $0x11679e <== NOT EXECUTED 1079f7: e8 6b fc ff ff call 107667 <== NOT EXECUTED if (tty->column) 1079fc: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1079ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a02: 85 c0 test %eax,%eax <== NOT EXECUTED 107a04: 74 04 je 107a0a <== NOT EXECUTED tty->column--; 107a06: 48 dec %eax <== NOT EXECUTED 107a07: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 107a0a: a1 b8 a9 11 00 mov 0x11a9b8,%eax <== NOT EXECUTED 107a0f: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 107a13: 74 06 je 107a1b <== NOT EXECUTED 107a15: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 107a19: 74 1c je 107a37 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 107a1b: 50 push %eax <== NOT EXECUTED 107a1c: 53 push %ebx <== NOT EXECUTED 107a1d: 6a 03 push $0x3 <== NOT EXECUTED 107a1f: 68 9e 67 11 00 push $0x11679e <== NOT EXECUTED 107a24: e8 3e fc ff ff call 107667 <== NOT EXECUTED if (tty->column) 107a29: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 107a2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a2f: 85 c0 test %eax,%eax <== NOT EXECUTED 107a31: 74 04 je 107a37 <== NOT EXECUTED tty->column--; 107a33: 48 dec %eax <== NOT EXECUTED 107a34: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } } } if (!lineFlag) 107a37: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 107a3b: 74 0b je 107a48 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 107a3d: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 107a40: 85 c9 test %ecx,%ecx <== NOT EXECUTED 107a42: 0f 85 fb fe ff ff jne 107943 <== NOT EXECUTED } } if (!lineFlag) break; } } 107a48: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107a4b: 5b pop %ebx <== NOT EXECUTED 107a4c: 5e pop %esi <== NOT EXECUTED 107a4d: 5f pop %edi <== NOT EXECUTED 107a4e: c9 leave <== NOT EXECUTED 107a4f: c3 ret <== NOT EXECUTED 001291bc : #include int fchdir( int fd ) { 1291bc: 55 push %ebp <== NOT EXECUTED 1291bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1291bf: 57 push %edi <== NOT EXECUTED 1291c0: 56 push %esi <== NOT EXECUTED 1291c1: 53 push %ebx <== NOT EXECUTED 1291c2: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1291c5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); 1291c8: 3b 05 f8 11 14 00 cmp 0x1411f8,%eax <== NOT EXECUTED 1291ce: 73 11 jae 1291e1 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1291d0: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 1291d3: 03 05 88 9a 15 00 add 0x159a88,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 1291d9: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 1291dc: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 1291df: 75 10 jne 1291f1 <== NOT EXECUTED 1291e1: e8 ba 18 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1291e6: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1291ec: e9 8f 00 00 00 jmp 129280 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 1291f1: 80 e2 02 and $0x2,%dl <== NOT EXECUTED 1291f4: 75 0d jne 129203 <== NOT EXECUTED 1291f6: e8 a5 18 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1291fb: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129201: eb 7d jmp 129280 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 129203: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 129206: 85 d2 test %edx,%edx <== NOT EXECUTED 129208: 74 07 je 129211 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 12920a: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 12920d: 85 d2 test %edx,%edx <== NOT EXECUTED 12920f: 75 0d jne 12921e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 129211: e8 8a 18 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 129216: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12921c: eb 62 jmp 129280 <== NOT EXECUTED } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 12921e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129221: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 129224: 53 push %ebx <== NOT EXECUTED 129225: ff d2 call *%edx <== NOT EXECUTED 129227: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12922a: 48 dec %eax <== NOT EXECUTED 12922b: 74 0d je 12923a <== NOT EXECUTED RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 12922d: e8 6e 18 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 129232: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 129238: eb 46 jmp 129280 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 12923a: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 12923f: 8d 7d d4 lea -0x2c(%ebp),%edi <== NOT EXECUTED 129242: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 129245: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12924a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 12924c: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12924f: b1 04 mov $0x4,%cl <== NOT EXECUTED 129251: 89 de mov %ebx,%esi <== NOT EXECUTED 129253: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 129255: 6a 00 push $0x0 <== NOT EXECUTED 129257: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 12925a: 50 push %eax <== NOT EXECUTED 12925b: 6a 00 push $0x0 <== NOT EXECUTED 12925d: 68 8f b1 13 00 push $0x13b18f <== NOT EXECUTED 129262: e8 93 0c fe ff call 109efa <== NOT EXECUTED 129267: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12926a: 85 c0 test %eax,%eax <== NOT EXECUTED 12926c: 74 17 je 129285 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 12926e: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 129273: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 129276: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 129279: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12927e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 129280: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129283: eb 2e jmp 1292b3 <== NOT EXECUTED return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 129285: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 129288: 85 c0 test %eax,%eax <== NOT EXECUTED 12928a: 74 13 je 12929f <== NOT EXECUTED 12928c: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 12928f: 85 d2 test %edx,%edx <== NOT EXECUTED 129291: 74 0c je 12929f <== NOT EXECUTED 129293: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129296: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 129299: 50 push %eax <== NOT EXECUTED 12929a: ff d2 call *%edx <== NOT EXECUTED 12929c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 12929f: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 1292a4: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 1292a7: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 1292aa: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1292af: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1292b1: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1292b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1292b6: 5b pop %ebx <== NOT EXECUTED 1292b7: 5e pop %esi <== NOT EXECUTED 1292b8: 5f pop %edi <== NOT EXECUTED 1292b9: c9 leave <== NOT EXECUTED 1292ba: c3 ret <== NOT EXECUTED 0011eea8 : int fchmod( int fd, mode_t mode ) { 11eea8: 55 push %ebp <== NOT EXECUTED 11eea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11eeab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11eeae: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11eeb1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11eeb4: 3b 05 f8 11 14 00 cmp 0x1411f8,%eax <== NOT EXECUTED 11eeba: 73 11 jae 11eecd <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11eebc: 6b d0 34 imul $0x34,%eax,%edx <== NOT EXECUTED 11eebf: 03 15 88 9a 15 00 add 0x159a88,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 11eec5: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11eec8: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 11eecb: 75 0d jne 11eeda <== NOT EXECUTED 11eecd: e8 ce bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11eed2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11eed8: eb 39 jmp 11ef13 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11eeda: a8 04 test $0x4,%al <== NOT EXECUTED 11eedc: 75 0d jne 11eeeb <== NOT EXECUTED 11eede: e8 bd bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11eee3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11eee9: eb 28 jmp 11ef13 <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 11eeeb: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 11eeee: 83 78 1c 00 cmpl $0x0,0x1c(%eax) <== NOT EXECUTED 11eef2: 75 0d jne 11ef01 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11eef4: e8 a7 bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11eef9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11eeff: eb 12 jmp 11ef13 <== NOT EXECUTED return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 11ef01: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 11ef04: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 11ef07: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 11ef0a: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 11ef0d: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED } 11ef10: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 11ef11: ff e1 jmp *%ecx <== NOT EXECUTED } 11ef13: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11ef16: c9 leave <== NOT EXECUTED 11ef17: c3 ret <== NOT EXECUTED 0011ef18 : int fchown( int fd, uid_t owner, gid_t group ) { 11ef18: 55 push %ebp <== NOT EXECUTED 11ef19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ef1b: 56 push %esi <== NOT EXECUTED 11ef1c: 53 push %ebx <== NOT EXECUTED 11ef1d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11ef20: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11ef23: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11ef26: 3b 05 f8 11 14 00 cmp 0x1411f8,%eax <== NOT EXECUTED 11ef2c: 73 11 jae 11ef3f <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11ef2e: 6b d0 34 imul $0x34,%eax,%edx <== NOT EXECUTED 11ef31: 03 15 88 9a 15 00 add 0x159a88,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 11ef37: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11ef3a: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 11ef3d: 75 0d jne 11ef4c <== NOT EXECUTED 11ef3f: e8 5c bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ef44: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11ef4a: eb 3f jmp 11ef8b <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11ef4c: a8 04 test $0x4,%al <== NOT EXECUTED 11ef4e: 75 0d jne 11ef5d <== NOT EXECUTED 11ef50: e8 4b bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ef55: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11ef5b: eb 2e jmp 11ef8b <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 11ef5d: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 11ef60: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED 11ef63: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11ef65: 75 0d jne 11ef74 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ef67: e8 34 bb 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ef6c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ef72: eb 17 jmp 11ef8b <== NOT EXECUTED return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 11ef74: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 11ef77: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11ef7a: 0f b7 c6 movzwl %si,%eax <== NOT EXECUTED 11ef7d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11ef80: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 11ef83: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11ef86: 5b pop %ebx <== NOT EXECUTED 11ef87: 5e pop %esi <== NOT EXECUTED 11ef88: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 11ef89: ff e1 jmp *%ecx <== NOT EXECUTED } 11ef8b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11ef8e: 5b pop %ebx <== NOT EXECUTED 11ef8f: 5e pop %esi <== NOT EXECUTED 11ef90: c9 leave <== NOT EXECUTED 11ef91: c3 ret <== NOT EXECUTED 001292bc : int fcntl( int fd, int cmd, ... ) { 1292bc: 55 push %ebp <== NOT EXECUTED 1292bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1292bf: 57 push %edi <== NOT EXECUTED 1292c0: 56 push %esi <== NOT EXECUTED 1292c1: 53 push %ebx <== NOT EXECUTED 1292c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1292c5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1292c8: 8d 55 10 lea 0x10(%ebp),%edx <== NOT EXECUTED int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 1292cb: 8b 0d f8 11 14 00 mov 0x1411f8,%ecx <== NOT EXECUTED 1292d1: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 1292d3: 73 14 jae 1292e9 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1292d5: 8b 35 88 9a 15 00 mov 0x159a88,%esi <== NOT EXECUTED 1292db: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 1292de: 8d 1c 06 lea (%esi,%eax,1),%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1292e1: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1292e4: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 1292e7: 75 10 jne 1292f9 <== NOT EXECUTED 1292e9: e8 b2 17 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1292ee: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1292f4: e9 fc 00 00 00 jmp 1293f5 <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1292f9: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) <== NOT EXECUTED 1292fd: 0f 87 bf 00 00 00 ja 1293c2 <== NOT EXECUTED 129303: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 129306: ff 24 bd 14 e3 13 00 jmp *0x13e314(,%edi,4) <== NOT EXECUTED case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 12930d: 8b 02 mov (%edx),%eax <== NOT EXECUTED if ( fd2 ) 12930f: 85 c0 test %eax,%eax <== NOT EXECUTED 129311: 74 0e je 129321 <== NOT EXECUTED diop = rtems_libio_iop( fd2 ); 129313: 31 d2 xor %edx,%edx <== NOT EXECUTED 129315: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 129317: 73 1a jae 129333 <== NOT EXECUTED 129319: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 12931c: 8d 14 06 lea (%esi,%eax,1),%edx <== NOT EXECUTED 12931f: eb 12 jmp 129333 <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 129321: e8 d7 0f fe ff call 10a2fd <== NOT EXECUTED 129326: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( diop == 0 ) { 129328: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 12932b: 85 c0 test %eax,%eax <== NOT EXECUTED 12932d: 0f 84 c5 00 00 00 je 1293f8 <== NOT EXECUTED ret = -1; break; } } diop->handlers = iop->handlers; 129333: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 129336: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED diop->file_info = iop->file_info; 129339: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 12933c: 89 42 2c mov %eax,0x2c(%edx) <== NOT EXECUTED diop->flags = iop->flags; 12933f: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 129342: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED diop->pathinfo = iop->pathinfo; 129345: 8d 7a 10 lea 0x10(%edx),%edi <== NOT EXECUTED 129348: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 12934b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 129350: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ret = (int) (diop - rtems_libio_iops); 129352: 2b 15 88 9a 15 00 sub 0x159a88,%edx <== NOT EXECUTED 129358: c1 fa 02 sar $0x2,%edx <== NOT EXECUTED 12935b: 69 f2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%esi <== NOT EXECUTED 129361: eb 6c jmp 1293cf <== NOT EXECUTED break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 129363: 89 c6 mov %eax,%esi <== NOT EXECUTED 129365: c1 ee 0b shr $0xb,%esi <== NOT EXECUTED 129368: 83 e6 01 and $0x1,%esi <== NOT EXECUTED 12936b: eb 66 jmp 1293d3 <== NOT EXECUTED * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) 12936d: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 129370: 74 05 je 129377 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 129372: 80 cc 08 or $0x8,%ah <== NOT EXECUTED 129375: eb 03 jmp 12937a <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 129377: 80 e4 f7 and $0xf7,%ah <== NOT EXECUTED 12937a: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 12937d: 31 f6 xor %esi,%esi <== NOT EXECUTED 12937f: eb 52 jmp 1293d3 <== NOT EXECUTED break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 129381: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129384: 50 push %eax <== NOT EXECUTED 129385: e8 26 0e fe ff call 10a1b0 <== NOT EXECUTED 12938a: 89 c6 mov %eax,%esi <== NOT EXECUTED 12938c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12938f: eb 3e jmp 1293cf <== NOT EXECUTED break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 129391: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129394: ff 32 pushl (%edx) <== NOT EXECUTED 129396: e8 f4 0f fe ff call 10a38f <== NOT EXECUTED /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 12939b: 25 01 02 00 00 and $0x201,%eax <== NOT EXECUTED 1293a0: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 1293a3: 81 e2 fe fd ff ff and $0xfffffdfe,%edx <== NOT EXECUTED 1293a9: 09 c2 or %eax,%edx <== NOT EXECUTED 1293ab: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 1293ae: 31 f6 xor %esi,%esi <== NOT EXECUTED 1293b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1293b3: eb 1e jmp 1293d3 <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 1293b5: e8 e6 16 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1293ba: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1293c0: eb 33 jmp 1293f5 <== NOT EXECUTED ret = -1; break; default: errno = EINVAL; 1293c2: e8 d9 16 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1293c7: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1293cd: eb 26 jmp 1293f5 <== NOT EXECUTED /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 1293cf: 85 f6 test %esi,%esi <== NOT EXECUTED 1293d1: 78 25 js 1293f8 <== NOT EXECUTED if (iop->handlers->fcntl_h) { 1293d3: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 1293d6: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 1293d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1293db: 74 1b je 1293f8 <== NOT EXECUTED int err = (*iop->handlers->fcntl_h)( cmd, iop ); 1293dd: 52 push %edx <== NOT EXECUTED 1293de: 52 push %edx <== NOT EXECUTED 1293df: 53 push %ebx <== NOT EXECUTED 1293e0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1293e3: ff d0 call *%eax <== NOT EXECUTED 1293e5: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err) { 1293e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1293ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1293ec: 74 0a je 1293f8 <== NOT EXECUTED errno = err; 1293ee: e8 ad 16 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1293f3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 1293f5: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 1293f8: 89 f0 mov %esi,%eax <== NOT EXECUTED 1293fa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1293fd: 5b pop %ebx <== NOT EXECUTED 1293fe: 5e pop %esi <== NOT EXECUTED 1293ff: 5f pop %edi <== NOT EXECUTED 129400: c9 leave <== NOT EXECUTED 129401: c3 ret <== NOT EXECUTED 001209c6 : bool file_systems_below_this_mountpoint( const char *path, rtems_filesystem_location_info_t *fs_root_loc, rtems_filesystem_mount_table_entry_t *fs_to_unmount ) { 1209c6: 55 push %ebp <== NOT EXECUTED 1209c7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1209c9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 1209cc: 8b 15 24 9b 15 00 mov 0x159b24,%edx <== NOT EXECUTED 1209d2: eb 0e jmp 1209e2 <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 1209d4: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 1209d7: 3b 41 0c cmp 0xc(%ecx),%eax <== NOT EXECUTED 1209da: 75 04 jne 1209e0 <== NOT EXECUTED 1209dc: b0 01 mov $0x1,%al <== NOT EXECUTED 1209de: eb 0c jmp 1209ec <== NOT EXECUTED * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 1209e0: 8b 12 mov (%edx),%edx <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 1209e2: 81 fa 28 9b 15 00 cmp $0x159b28,%edx <== NOT EXECUTED 1209e8: 75 ea jne 1209d4 <== NOT EXECUTED 1209ea: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 1209ec: c9 leave <== NOT EXECUTED 1209ed: c3 ret <== NOT EXECUTED 00106468 : void free( void *ptr ) { MSBUMP(free_calls, 1); 106468: 55 push %ebp <== NOT EXECUTED 106469: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10646b: 53 push %ebx <== NOT EXECUTED 10646c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10646f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 106472: ff 05 1c c9 11 00 incl 0x11c91c <== NOT EXECUTED if ( !ptr ) 106478: 85 db test %ebx,%ebx <== NOT EXECUTED 10647a: 74 5f je 1064db <== NOT EXECUTED /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10647c: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 106483: 75 15 jne 10649a <== NOT EXECUTED 106485: e8 de 00 00 00 call 106568 <== NOT EXECUTED 10648a: 84 c0 test %al,%al <== NOT EXECUTED 10648c: 75 0c jne 10649a <== NOT EXECUTED !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10648e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 106491: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106494: 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); 106495: e9 0d 01 00 00 jmp 1065a7 <== NOT EXECUTED #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 10649a: a1 74 ae 11 00 mov 0x11ae74,%eax <== NOT EXECUTED 10649f: 85 c0 test %eax,%eax <== NOT EXECUTED 1064a1: 74 0a je 1064ad <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_free)(ptr); 1064a3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1064a6: 53 push %ebx <== NOT EXECUTED 1064a7: ff 50 08 call *0x8(%eax) <== NOT EXECUTED 1064aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 1064ad: 50 push %eax <== NOT EXECUTED 1064ae: 50 push %eax <== NOT EXECUTED 1064af: 53 push %ebx <== NOT EXECUTED 1064b0: 68 b8 c8 11 00 push $0x11c8b8 <== NOT EXECUTED 1064b5: e8 e6 43 00 00 call 10a8a0 <_Protected_heap_Free> <== NOT EXECUTED 1064ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1064bd: 84 c0 test %al,%al <== NOT EXECUTED 1064bf: 75 1a jne 1064db <== NOT EXECUTED printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 1064c1: ff 35 d4 c8 11 00 pushl 0x11c8d4 <== NOT EXECUTED 1064c7: ff 35 d0 c8 11 00 pushl 0x11c8d0 <== NOT EXECUTED 1064cd: 53 push %ebx <== NOT EXECUTED 1064ce: 68 48 67 11 00 push $0x116748 <== NOT EXECUTED 1064d3: e8 5a 0b 00 00 call 107032 <== NOT EXECUTED 1064d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 1064db: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1064de: c9 leave <== NOT EXECUTED 1064df: c3 ret <== NOT EXECUTED 00120324 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 120324: 55 push %ebp <== NOT EXECUTED 120325: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120327: 53 push %ebx <== NOT EXECUTED 120328: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 12032b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 12032e: 81 fb 84 9f 15 00 cmp $0x159f84,%ebx <== NOT EXECUTED 120334: 74 40 je 120376 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 120336: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 120339: 85 c0 test %eax,%eax <== NOT EXECUTED 12033b: 74 13 je 120350 <== NOT EXECUTED 12033d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 120340: 85 d2 test %edx,%edx <== NOT EXECUTED 120342: 74 0c je 120350 <== NOT EXECUTED 120344: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120347: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 12034a: 50 push %eax <== NOT EXECUTED 12034b: ff d2 call *%edx <== NOT EXECUTED 12034d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 120350: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 120353: 85 c0 test %eax,%eax <== NOT EXECUTED 120355: 74 13 je 12036a <== NOT EXECUTED 120357: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 12035a: 85 d2 test %edx,%edx <== NOT EXECUTED 12035c: 74 0c je 12036a <== NOT EXECUTED 12035e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120361: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 120364: 50 push %eax <== NOT EXECUTED 120365: ff d2 call *%edx <== NOT EXECUTED 120367: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 12036a: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 12036d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120370: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 120371: e9 a6 9c fe ff jmp 10a01c <== NOT EXECUTED } } 120376: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120379: c9 leave <== NOT EXECUTED 12037a: c3 ret <== NOT EXECUTED 00114ac8 : int fstat( int fd, struct stat *sbuf ) { 114ac8: 55 push %ebp <== NOT EXECUTED 114ac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114acb: 57 push %edi <== NOT EXECUTED 114acc: 56 push %esi <== NOT EXECUTED 114acd: 53 push %ebx <== NOT EXECUTED 114ace: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114ad1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ad4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 114ad7: 85 f6 test %esi,%esi <== NOT EXECUTED 114ad9: 75 0d jne 114ae8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 114adb: e8 d0 9b ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114ae0: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 114ae6: eb 54 jmp 114b3c <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 114ae8: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 114aee: 73 57 jae 114b47 <== NOT EXECUTED 114af0: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 114af3: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 114af9: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 114afd: 74 48 je 114b47 <== NOT EXECUTED if ( !iop->handlers ) 114aff: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 114b02: 85 c0 test %eax,%eax <== NOT EXECUTED 114b04: 74 41 je 114b47 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 114b06: 83 78 18 00 cmpl $0x0,0x18(%eax) <== NOT EXECUTED 114b0a: 75 0d jne 114b19 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 114b0c: e8 9f 9b ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114b11: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 114b17: eb 23 jmp 114b3c <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 114b19: b9 13 00 00 00 mov $0x13,%ecx <== NOT EXECUTED 114b1e: 31 c0 xor %eax,%eax <== NOT EXECUTED 114b20: 89 f7 mov %esi,%edi <== NOT EXECUTED 114b22: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 114b24: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 114b27: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 114b2a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 114b2d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 114b30: 8b 4a 18 mov 0x18(%edx),%ecx <== NOT EXECUTED } 114b33: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 114b36: 5b pop %ebx <== NOT EXECUTED 114b37: 5e pop %esi <== NOT EXECUTED 114b38: 5f pop %edi <== NOT EXECUTED 114b39: c9 leave <== NOT EXECUTED * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 114b3a: ff e1 jmp *%ecx <== NOT EXECUTED } 114b3c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114b3f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 114b42: 5b pop %ebx <== NOT EXECUTED 114b43: 5e pop %esi <== NOT EXECUTED 114b44: 5f pop %edi <== NOT EXECUTED 114b45: c9 leave <== NOT EXECUTED 114b46: c3 ret <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); 114b47: e8 64 9b ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114b4c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 114b52: eb e8 jmp 114b3c <== NOT EXECUTED 0011f038 : #include int fsync( int fd ) { 11f038: 55 push %ebp <== NOT EXECUTED 11f039: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f03b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11f03e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11f041: 3b 05 f8 11 14 00 cmp 0x1411f8,%eax <== NOT EXECUTED 11f047: 73 2a jae 11f073 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11f049: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 11f04c: 03 05 88 9a 15 00 add 0x159a88,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 11f052: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 11f055: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 11f058: 74 19 je 11f073 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11f05a: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 11f05d: 75 0d jne 11f06c <== NOT EXECUTED 11f05f: e8 3c ba 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f064: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f06a: eb 2e jmp 11f09a <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) 11f06c: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 11f06f: 85 d2 test %edx,%edx <== NOT EXECUTED 11f071: 75 0d jne 11f080 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 11f073: e8 28 ba 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f078: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11f07e: eb 1a jmp 11f09a <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 11f080: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 11f083: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11f085: 75 0d jne 11f094 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11f087: e8 14 ba 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f08c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11f092: eb 06 jmp 11f09a <== NOT EXECUTED return (*iop->handlers->fsync_h)( iop ); 11f094: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11f097: c9 leave <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 11f098: ff e1 jmp *%ecx <== NOT EXECUTED } 11f09a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11f09d: c9 leave <== NOT EXECUTED 11f09e: c3 ret <== NOT EXECUTED 0010cca4 : int ftruncate( int fd, off_t length ) { 10cca4: 55 push %ebp <== NOT EXECUTED 10cca5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cca7: 57 push %edi <== NOT EXECUTED 10cca8: 56 push %esi <== NOT EXECUTED 10cca9: 53 push %ebx <== NOT EXECUTED 10ccaa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ccad: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10ccb0: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 10ccb6: 73 0f jae 10ccc7 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 10ccb8: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 10ccbb: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10ccc1: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10ccc5: 75 0d jne 10ccd4 <== NOT EXECUTED 10ccc7: e8 e4 19 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cccc: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10ccd2: eb 5b jmp 10cd2f <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10ccd4: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ccd7: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10ccda: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ccdf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 10cce1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10cce4: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 10cce7: 85 d2 test %edx,%edx <== NOT EXECUTED 10cce9: 74 39 je 10cd24 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10cceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccee: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ccf1: 50 push %eax <== NOT EXECUTED 10ccf2: ff d2 call *%edx <== NOT EXECUTED 10ccf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ccf7: 48 dec %eax <== NOT EXECUTED 10ccf8: 75 0d jne 10cd07 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 10ccfa: e8 b1 19 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10ccff: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10cd05: eb 28 jmp 10cd2f <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10cd07: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED 10cd0b: 75 0d jne 10cd1a <== NOT EXECUTED 10cd0d: e8 9e 19 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cd12: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10cd18: eb 15 jmp 10cd2f <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10cd1a: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10cd1d: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10cd20: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd22: 75 10 jne 10cd34 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10cd24: e8 87 19 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cd29: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cd2f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cd32: eb 0b jmp 10cd3f <== NOT EXECUTED return (*iop->handlers->ftruncate_h)( iop, length ); 10cd34: 52 push %edx <== NOT EXECUTED 10cd35: 52 push %edx <== NOT EXECUTED 10cd36: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cd39: 53 push %ebx <== NOT EXECUTED 10cd3a: ff d0 call *%eax <== NOT EXECUTED 10cd3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cd3f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd42: 5b pop %ebx <== NOT EXECUTED 10cd43: 5e pop %esi <== NOT EXECUTED 10cd44: 5f pop %edi <== NOT EXECUTED 10cd45: c9 leave <== NOT EXECUTED 10cd46: c3 ret <== NOT EXECUTED 0011f144 : char * getcwd ( char *pt, size_t size) { 11f144: 55 push %ebp <== NOT EXECUTED 11f145: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f147: 57 push %edi <== NOT EXECUTED 11f148: 56 push %esi <== NOT EXECUTED 11f149: 53 push %ebx <== NOT EXECUTED 11f14a: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 11f150: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED * If no buffer specified by the user, allocate one as necessary. * If a buffer is specified, the size has to be non-zero. The path * is built from the end of the buffer backwards. */ if (pt) 11f153: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11f157: 74 2a je 11f183 <== NOT EXECUTED { ptsize = 0; if (!size) 11f159: 85 c0 test %eax,%eax <== NOT EXECUTED 11f15b: 75 17 jne 11f174 <== NOT EXECUTED { errno = EINVAL; 11f15d: e8 3e b9 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f162: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f168: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 11f16f: e9 c0 03 00 00 jmp 11f534 <== NOT EXECUTED return (char *) NULL; } ept = pt + size; 11f174: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 11f177: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 11f17a: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f181: eb 2a jmp 11f1ad <== NOT EXECUTED } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 11f183: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f186: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 11f18b: e8 4c b3 fe ff call 10a4dc <== NOT EXECUTED 11f190: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 11f193: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f196: 85 c0 test %eax,%eax <== NOT EXECUTED 11f198: 0f 84 96 03 00 00 je 11f534 <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 11f19e: 05 fc 03 00 00 add $0x3fc,%eax <== NOT EXECUTED 11f1a3: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 11f1a6: c7 45 8c fc 03 00 00 movl $0x3fc,-0x74(%ebp) <== NOT EXECUTED } bpt = ept - 1; 11f1ad: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 11f1b0: 48 dec %eax <== NOT EXECUTED 11f1b1: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED *bpt = '\0'; 11f1b4: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 11f1b7: c6 42 ff 00 movb $0x0,-0x1(%edx) <== NOT EXECUTED * Allocate bytes (1024 - malloc space) for the string of "../"'s. * Should always be enough (it's 340 levels). If it's not, allocate * as necessary. Special * case the first stat, it's ".", not "..". */ if (!(up = (char *) malloc (upsize = 1024 - 4))) 11f1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f1be: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 11f1c3: e8 14 b3 fe ff call 10a4dc <== NOT EXECUTED 11f1c8: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f1ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f1cd: 85 c0 test %eax,%eax <== NOT EXECUTED 11f1cf: 0f 84 38 03 00 00 je 11f50d <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 11f1d5: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED up[1] = '\0'; 11f1d8: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED /* Save root values, so know when to stop. */ if (stat ("/", &s)) 11f1dc: 50 push %eax <== NOT EXECUTED 11f1dd: 50 push %eax <== NOT EXECUTED 11f1de: 8d 5d a8 lea -0x58(%ebp),%ebx <== NOT EXECUTED 11f1e1: 53 push %ebx <== NOT EXECUTED 11f1e2: 68 33 d0 13 00 push $0x13d033 <== NOT EXECUTED 11f1e7: e8 a0 c1 fe ff call 10b38c <== NOT EXECUTED 11f1ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f1ef: 85 c0 test %eax,%eax <== NOT EXECUTED 11f1f1: 0f 85 16 03 00 00 jne 11f50d <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 11f1f7: 8d be 00 04 00 00 lea 0x400(%esi),%edi <== NOT EXECUTED 11f1fd: 89 7d 9c mov %edi,-0x64(%ebp) <== NOT EXECUTED up[1] = '\0'; /* Save root values, so know when to stop. */ if (stat ("/", &s)) goto err; root_dev = s.st_dev; 11f200: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 11f203: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 11f209: 8b 55 ac mov -0x54(%ebp),%edx <== NOT EXECUTED 11f20c: 89 95 60 ff ff ff mov %edx,-0xa0(%ebp) <== NOT EXECUTED root_ino = s.st_ino; 11f212: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED 11f215: 89 7d 88 mov %edi,-0x78(%ebp) <== NOT EXECUTED errno = 0; /* XXX readdir has no error return. */ 11f218: e8 83 b8 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f21d: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11f223: 89 75 84 mov %esi,-0x7c(%ebp) <== NOT EXECUTED 11f226: c7 85 7c ff ff ff 01 movl $0x1,-0x84(%ebp) <== NOT EXECUTED 11f22d: 00 00 00 <== NOT EXECUTED 11f230: c7 45 90 fc 03 00 00 movl $0x3fc,-0x70(%ebp) <== NOT EXECUTED for (first = 1;; first = 0) { /* Stat the current level. */ if (_stat (up, &s)) 11f237: 57 push %edi <== NOT EXECUTED 11f238: 57 push %edi <== NOT EXECUTED 11f239: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 11f23c: 50 push %eax <== NOT EXECUTED 11f23d: 56 push %esi <== NOT EXECUTED 11f23e: e8 49 c1 fe ff call 10b38c <== NOT EXECUTED 11f243: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f246: 85 c0 test %eax,%eax <== NOT EXECUTED 11f248: 0f 85 bf 02 00 00 jne 11f50d <== NOT EXECUTED goto err; /* Save current node values. */ ino = s.st_ino; 11f24e: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED 11f251: 89 95 78 ff ff ff mov %edx,-0x88(%ebp) <== NOT EXECUTED dev = s.st_dev; 11f257: 8b 7d a8 mov -0x58(%ebp),%edi <== NOT EXECUTED 11f25a: 89 bd 5c ff ff ff mov %edi,-0xa4(%ebp) <== NOT EXECUTED 11f260: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED 11f263: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) <== NOT EXECUTED /* Check for reaching root. */ if (root_dev == dev && root_ino == ino) 11f269: 39 85 60 ff ff ff cmp %eax,-0xa0(%ebp) <== NOT EXECUTED 11f26f: 75 35 jne 11f2a6 <== NOT EXECUTED 11f271: 39 bd 64 ff ff ff cmp %edi,-0x9c(%ebp) <== NOT EXECUTED 11f277: 75 2d jne 11f2a6 <== NOT EXECUTED 11f279: 39 55 88 cmp %edx,-0x78(%ebp) <== NOT EXECUTED 11f27c: 75 28 jne 11f2a6 <== NOT EXECUTED { *--bpt = '/'; 11f27e: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 11f281: 48 dec %eax <== NOT EXECUTED 11f282: 8b 55 80 mov -0x80(%ebp),%edx <== NOT EXECUTED 11f285: c6 42 ff 2f movb $0x2f,-0x1(%edx) <== NOT EXECUTED /* * It's unclear that it's a requirement to copy the * path to the beginning of the buffer, but it's always * been that way and stuff would probably break. */ (void) bcopy (bpt, pt, ept - bpt); 11f289: 53 push %ebx <== NOT EXECUTED 11f28a: 29 45 98 sub %eax,-0x68(%ebp) <== NOT EXECUTED 11f28d: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 11f290: 50 push %eax <== NOT EXECUTED 11f291: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f294: e8 07 da 00 00 call 12cca0 <== NOT EXECUTED free (up); 11f299: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11f29c: e8 7b ad fe ff call 10a01c <== NOT EXECUTED 11f2a1: e9 8b 02 00 00 jmp 11f531 <== NOT EXECUTED * Build pointer to the parent directory, allocating memory * as necessary. Max length is 3 for "../", the largest * possible component name, plus a trailing NULL. */ if (bup + 3 + MAXNAMLEN + 1 >= eup) 11f2a6: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f2a9: 05 04 04 00 00 add $0x404,%eax <== NOT EXECUTED 11f2ae: 39 45 9c cmp %eax,-0x64(%ebp) <== NOT EXECUTED 11f2b1: 77 26 ja 11f2d9 <== NOT EXECUTED { if (!(up = (char *) realloc (up, upsize *= 2))) 11f2b3: d1 65 90 shll -0x70(%ebp) <== NOT EXECUTED 11f2b6: 51 push %ecx <== NOT EXECUTED 11f2b7: 51 push %ecx <== NOT EXECUTED 11f2b8: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 11f2bb: 56 push %esi <== NOT EXECUTED 11f2bc: e8 d7 bf fe ff call 10b298 <== NOT EXECUTED 11f2c1: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f2c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f2c6: 85 c0 test %eax,%eax <== NOT EXECUTED 11f2c8: 0f 84 3f 02 00 00 je 11f50d <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 11f2ce: 8b 7d 90 mov -0x70(%ebp),%edi <== NOT EXECUTED 11f2d1: 01 c7 add %eax,%edi <== NOT EXECUTED 11f2d3: 89 7d 9c mov %edi,-0x64(%ebp) <== NOT EXECUTED 11f2d6: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED } *bup++ = '.'; 11f2d9: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f2dc: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED *bup++ = '.'; 11f2df: c6 40 01 2e movb $0x2e,0x1(%eax) <== NOT EXECUTED 11f2e3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f2e5: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED *bup = '\0'; 11f2e8: c6 40 02 00 movb $0x0,0x2(%eax) <== NOT EXECUTED /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 11f2ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f2ef: 56 push %esi <== NOT EXECUTED 11f2f0: e8 a7 0f 00 00 call 12029c <== NOT EXECUTED 11f2f5: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp) <== NOT EXECUTED 11f2fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f2fe: 85 c0 test %eax,%eax <== NOT EXECUTED 11f300: 0f 84 07 02 00 00 je 11f50d <== NOT EXECUTED 11f306: 52 push %edx <== NOT EXECUTED 11f307: 52 push %edx <== NOT EXECUTED 11f308: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 11f30b: 52 push %edx <== NOT EXECUTED 11f30c: ff 30 pushl (%eax) <== NOT EXECUTED 11f30e: e8 81 fc ff ff call 11ef94 <== NOT EXECUTED 11f313: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f316: 85 c0 test %eax,%eax <== NOT EXECUTED 11f318: 0f 85 21 02 00 00 jne 11f53f <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 11f31e: c6 03 2f movb $0x2f,(%ebx) <== NOT EXECUTED 11f321: 83 45 84 03 addl $0x3,-0x7c(%ebp) <== NOT EXECUTED * the inode number in the directory is for the entry in the * parent directory, not the inode number of the mounted file. */ save_errno = 0; if (s.st_dev == dev) 11f325: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 11f32b: 39 7d ac cmp %edi,-0x54(%ebp) <== NOT EXECUTED 11f32e: 75 0b jne 11f33b <== NOT EXECUTED 11f330: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax <== NOT EXECUTED 11f336: 39 45 a8 cmp %eax,-0x58(%ebp) <== NOT EXECUTED 11f339: 74 09 je 11f344 <== NOT EXECUTED 11f33b: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f342: eb 2a jmp 11f36e <== NOT EXECUTED { for (;;) { if (!(dp = _readdir (dir))) 11f344: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f347: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f34d: e8 ca 11 00 00 call 12051c <== NOT EXECUTED 11f352: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f354: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f357: 85 c0 test %eax,%eax <== NOT EXECUTED 11f359: 0f 84 84 01 00 00 je 11f4e3 <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 11f35f: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx <== NOT EXECUTED 11f365: 39 10 cmp %edx,(%eax) <== NOT EXECUTED 11f367: 75 db jne 11f344 <== NOT EXECUTED 11f369: e9 a8 00 00 00 jmp 11f416 <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 11f36e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f371: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f377: e8 a0 11 00 00 call 12051c <== NOT EXECUTED 11f37c: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f37e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f381: 85 c0 test %eax,%eax <== NOT EXECUTED 11f383: 0f 84 61 01 00 00 je 11f4ea <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 11f389: 80 78 0c 2e cmpb $0x2e,0xc(%eax) <== NOT EXECUTED 11f38d: 75 11 jne 11f3a0 <== NOT EXECUTED 11f38f: 8a 40 0d mov 0xd(%eax),%al <== NOT EXECUTED 11f392: 84 c0 test %al,%al <== NOT EXECUTED 11f394: 74 d8 je 11f36e <== NOT EXECUTED 11f396: 3c 2e cmp $0x2e,%al <== NOT EXECUTED 11f398: 75 06 jne 11f3a0 <== NOT EXECUTED 11f39a: 80 7b 0e 00 cmpb $0x0,0xe(%ebx) <== NOT EXECUTED 11f39e: 74 ce je 11f36e <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 11f3a0: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED 11f3a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f3a5: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f3a8: 89 d7 mov %edx,%edi <== NOT EXECUTED 11f3aa: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f3ac: f7 d1 not %ecx <== NOT EXECUTED 11f3ae: 57 push %edi <== NOT EXECUTED 11f3af: 51 push %ecx <== NOT EXECUTED 11f3b0: 52 push %edx <== NOT EXECUTED 11f3b1: ff 75 84 pushl -0x7c(%ebp) <== NOT EXECUTED 11f3b4: e8 e7 d8 00 00 call 12cca0 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 11f3b9: 58 pop %eax <== NOT EXECUTED 11f3ba: 5a pop %edx <== NOT EXECUTED 11f3bb: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 11f3be: 50 push %eax <== NOT EXECUTED 11f3bf: 56 push %esi <== NOT EXECUTED 11f3c0: e8 c7 bf fe ff call 10b38c <== NOT EXECUTED 11f3c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f3c8: 85 c0 test %eax,%eax <== NOT EXECUTED 11f3ca: 74 1d je 11f3e9 <== NOT EXECUTED { if (!save_errno) 11f3cc: 83 7d 94 00 cmpl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f3d0: 75 0a jne 11f3dc <== NOT EXECUTED save_errno = errno; 11f3d2: e8 c9 b6 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f3d7: 8b 00 mov (%eax),%eax <== NOT EXECUTED 11f3d9: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED errno = 0; 11f3dc: e8 bf b6 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f3e1: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11f3e7: eb 85 jmp 11f36e <== NOT EXECUTED continue; } if (s.st_dev == dev && s.st_ino == ino) 11f3e9: 8b 95 58 ff ff ff mov -0xa8(%ebp),%edx <== NOT EXECUTED 11f3ef: 39 55 ac cmp %edx,-0x54(%ebp) <== NOT EXECUTED 11f3f2: 0f 85 76 ff ff ff jne 11f36e <== NOT EXECUTED 11f3f8: 8b bd 5c ff ff ff mov -0xa4(%ebp),%edi <== NOT EXECUTED 11f3fe: 39 7d a8 cmp %edi,-0x58(%ebp) <== NOT EXECUTED 11f401: 0f 85 67 ff ff ff jne 11f36e <== NOT EXECUTED 11f407: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED 11f40d: 39 45 b0 cmp %eax,-0x50(%ebp) <== NOT EXECUTED 11f410: 0f 85 58 ff ff ff jne 11f36e <== NOT EXECUTED /* * Check for length of the current name, preceding slash, * leading slash. */ if (bpt - pt <= strlen (dp->d_name) + (first ? 1 : 2)) 11f416: 8b 55 80 mov -0x80(%ebp),%edx <== NOT EXECUTED 11f419: 2b 55 08 sub 0x8(%ebp),%edx <== NOT EXECUTED 11f41c: 89 55 a0 mov %edx,-0x60(%ebp) <== NOT EXECUTED 11f41f: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 11f422: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f424: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f427: 89 df mov %ebx,%edi <== NOT EXECUTED 11f429: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f42b: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 11f431: f7 d8 neg %eax <== NOT EXECUTED 11f433: 29 c8 sub %ecx,%eax <== NOT EXECUTED 11f435: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11f437: 77 5a ja 11f493 <== NOT EXECUTED { size_t len, off; if (!ptsize) 11f439: 83 7d 8c 00 cmpl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f43d: 75 10 jne 11f44f <== NOT EXECUTED { errno = ERANGE; 11f43f: e8 5c b6 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f444: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED 11f44a: e9 f0 00 00 00 jmp 11f53f <== NOT EXECUTED goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 11f44f: d1 65 8c shll -0x74(%ebp) <== NOT EXECUTED 11f452: 57 push %edi <== NOT EXECUTED 11f453: 57 push %edi <== NOT EXECUTED 11f454: ff 75 8c pushl -0x74(%ebp) <== NOT EXECUTED 11f457: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f45a: e8 39 be fe ff call 10b298 <== NOT EXECUTED 11f45f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 11f462: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f465: 85 c0 test %eax,%eax <== NOT EXECUTED 11f467: 0f 84 d2 00 00 00 je 11f53f <== NOT EXECUTED { errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; 11f46d: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 11f470: 2b 45 80 sub -0x80(%ebp),%eax <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 11f473: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11f476: 03 55 8c add -0x74(%ebp),%edx <== NOT EXECUTED 11f479: 89 55 98 mov %edx,-0x68(%ebp) <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 11f47c: 29 c2 sub %eax,%edx <== NOT EXECUTED 11f47e: 89 55 80 mov %edx,-0x80(%ebp) <== NOT EXECUTED 11f481: 51 push %ecx <== NOT EXECUTED 11f482: 50 push %eax <== NOT EXECUTED 11f483: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f486: 03 45 a0 add -0x60(%ebp),%eax <== NOT EXECUTED 11f489: 50 push %eax <== NOT EXECUTED 11f48a: 52 push %edx <== NOT EXECUTED 11f48b: e8 10 d8 00 00 call 12cca0 <== NOT EXECUTED 11f490: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bpt = ept - len; } if (!first) 11f493: 83 bd 7c ff ff ff 00 cmpl $0x0,-0x84(%ebp) <== NOT EXECUTED 11f49a: 75 09 jne 11f4a5 <== NOT EXECUTED *--bpt = '/'; 11f49c: ff 4d 80 decl -0x80(%ebp) <== NOT EXECUTED 11f49f: 8b 7d 80 mov -0x80(%ebp),%edi <== NOT EXECUTED 11f4a2: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED bpt -= strlen (dp->d_name); 11f4a5: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f4a7: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f4aa: 89 df mov %ebx,%edi <== NOT EXECUTED 11f4ac: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f4ae: f7 d1 not %ecx <== NOT EXECUTED 11f4b0: 49 dec %ecx <== NOT EXECUTED 11f4b1: 29 4d 80 sub %ecx,-0x80(%ebp) <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 11f4b4: 52 push %edx <== NOT EXECUTED 11f4b5: 51 push %ecx <== NOT EXECUTED 11f4b6: 53 push %ebx <== NOT EXECUTED 11f4b7: ff 75 80 pushl -0x80(%ebp) <== NOT EXECUTED 11f4ba: e8 e1 d7 00 00 call 12cca0 <== NOT EXECUTED (void) _closedir (dir); 11f4bf: 58 pop %eax <== NOT EXECUTED 11f4c0: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f4c6: e8 9d 9c 00 00 call 129168 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 11f4cb: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f4ce: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 11f4d1: c7 85 7c ff ff ff 00 movl $0x0,-0x84(%ebp) <== NOT EXECUTED 11f4d8: 00 00 00 <== NOT EXECUTED 11f4db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f4de: e9 54 fd ff ff jmp 11f237 <== NOT EXECUTED } 11f4e3: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED * If readdir set errno, use it, not any saved error; otherwise, * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) 11f4ea: e8 b1 b5 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f4ef: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 11f4f2: 75 4b jne 11f53f <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; 11f4f4: e8 a7 b5 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11f4f9: 83 7d 94 00 cmpl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f4fd: 75 07 jne 11f506 <== NOT EXECUTED 11f4ff: c7 45 94 02 00 00 00 movl $0x2,-0x6c(%ebp) <== NOT EXECUTED 11f506: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 11f509: 89 10 mov %edx,(%eax) <== NOT EXECUTED 11f50b: eb 32 jmp 11f53f <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 11f50d: 83 7d 8c 00 cmpl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f511: 74 0e je 11f521 <== NOT EXECUTED free (pt); 11f513: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f516: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f519: e8 fe aa fe ff call 10a01c <== NOT EXECUTED 11f51e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free (up); 11f521: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f524: 56 push %esi <== NOT EXECUTED 11f525: e8 f2 aa fe ff call 10a01c <== NOT EXECUTED 11f52a: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 11f531: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return (char *) NULL; } 11f534: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f537: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f53a: 5b pop %ebx <== NOT EXECUTED 11f53b: 5e pop %esi <== NOT EXECUTED 11f53c: 5f pop %edi <== NOT EXECUTED 11f53d: c9 leave <== NOT EXECUTED 11f53e: c3 ret <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 11f53f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f542: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f548: e8 1b 9c 00 00 call 129168 <== NOT EXECUTED 11f54d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f550: eb bb jmp 11f50d <== NOT EXECUTED 00129420 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 129420: 55 push %ebp <== NOT EXECUTED 129421: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129423: 57 push %edi <== NOT EXECUTED 129424: 56 push %esi <== NOT EXECUTED 129425: 53 push %ebx <== NOT EXECUTED 129426: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 129429: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 12942c: 31 db xor %ebx,%ebx <== NOT EXECUTED 12942e: 3b 05 f8 11 14 00 cmp 0x1411f8,%eax <== NOT EXECUTED 129434: 73 09 jae 12943f <== NOT EXECUTED 129436: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 129439: 03 1d 88 9a 15 00 add 0x159a88,%ebx <== NOT EXECUTED /* * Make sure we are working on a directory */ loc = iop->pathinfo; 12943f: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 129442: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 129445: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12944a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 12944c: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12944f: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 129452: 85 d2 test %edx,%edx <== NOT EXECUTED 129454: 74 29 je 12947f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 129456: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129459: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 12945c: 50 push %eax <== NOT EXECUTED 12945d: ff d2 call *%edx <== NOT EXECUTED 12945f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129462: 48 dec %eax <== NOT EXECUTED 129463: 74 10 je 129475 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 129465: e8 36 16 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 12946a: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 129470: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129473: eb 24 jmp 129499 <== NOT EXECUTED /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 129475: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 129478: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12947b: 85 c0 test %eax,%eax <== NOT EXECUTED 12947d: 75 0d jne 12948c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12947f: e8 1c 16 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 129484: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12948a: eb e4 jmp 129470 <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 12948c: 52 push %edx <== NOT EXECUTED 12948d: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 129490: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129493: 53 push %ebx <== NOT EXECUTED 129494: ff d0 call *%eax <== NOT EXECUTED 129496: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 129499: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12949c: 5b pop %ebx <== NOT EXECUTED 12949d: 5e pop %esi <== NOT EXECUTED 12949e: 5f pop %edi <== NOT EXECUTED 12949f: c9 leave <== NOT EXECUTED 1294a0: c3 ret <== NOT EXECUTED 0011f554 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getegid( void ) { 11f554: 55 push %ebp <== NOT EXECUTED 11f555: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f557: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11f55c: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED return _POSIX_types_Egid; } 11f55f: c9 leave <== NOT EXECUTED 11f560: c3 ret <== NOT EXECUTED 0011f564 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t geteuid( void ) { 11f564: 55 push %ebp <== NOT EXECUTED 11f565: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f567: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11f56c: 66 8b 40 2e mov 0x2e(%eax),%ax <== NOT EXECUTED return _POSIX_types_Euid; } 11f570: c9 leave <== NOT EXECUTED 11f571: c3 ret <== NOT EXECUTED 0011f574 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 11f574: 55 push %ebp <== NOT EXECUTED 11f575: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f577: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11f57c: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 11f57f: c9 leave <== NOT EXECUTED 11f580: c3 ret <== NOT EXECUTED 0011fa77 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fa77: 55 push %ebp <== NOT EXECUTED 11fa78: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fa7a: 57 push %edi <== NOT EXECUTED 11fa7b: 56 push %esi <== NOT EXECUTED 11fa7c: 53 push %ebx <== NOT EXECUTED 11fa7d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fa80: 89 c7 mov %eax,%edi <== NOT EXECUTED 11fa82: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 11fa85: 89 ce mov %ecx,%esi <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 11fa87: e8 df fe ff ff call 11f96b <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 11fa8c: 50 push %eax <== NOT EXECUTED 11fa8d: 50 push %eax <== NOT EXECUTED 11fa8e: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11fa93: 68 54 cf 13 00 push $0x13cf54 <== NOT EXECUTED 11fa98: e8 bb b8 00 00 call 12b358 <== NOT EXECUTED 11fa9d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fa9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11faa2: 85 c0 test %eax,%eax <== NOT EXECUTED 11faa4: 75 10 jne 11fab6 <== NOT EXECUTED errno = EINVAL; 11faa6: e8 f5 af 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11faab: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11fab1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fab4: eb 6b jmp 11fb21 <== NOT EXECUTED return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 11fab6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fab9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11fabc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11fabf: 89 f2 mov %esi,%edx <== NOT EXECUTED 11fac1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11fac3: e8 42 fc ff ff call 11f70a <== NOT EXECUTED 11fac8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11facb: 85 c0 test %eax,%eax <== NOT EXECUTED 11facd: 75 19 jne 11fae8 <== NOT EXECUTED errno = EINVAL; 11facf: e8 cc af 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11fad4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 11fada: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fadd: 53 push %ebx <== NOT EXECUTED 11fade: e8 09 b1 00 00 call 12abec <== NOT EXECUTED 11fae3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fae6: eb 36 jmp 11fb1e <== NOT EXECUTED return -1; } if (name) { 11fae8: 85 ff test %edi,%edi <== NOT EXECUTED 11faea: 74 11 je 11fafd <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); 11faec: 50 push %eax <== NOT EXECUTED 11faed: 50 push %eax <== NOT EXECUTED 11faee: 57 push %edi <== NOT EXECUTED 11faef: ff 36 pushl (%esi) <== NOT EXECUTED 11faf1: e8 fa f3 00 00 call 12eef0 <== NOT EXECUTED 11faf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11faf9: 85 c0 test %eax,%eax <== NOT EXECUTED 11fafb: eb 07 jmp 11fb04 <== NOT EXECUTED } else { match = (grp->gr_gid == gid); 11fafd: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 11fb01: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 11fb04: 0f 94 c0 sete %al <== NOT EXECUTED 11fb07: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 11fb0a: 85 c0 test %eax,%eax <== NOT EXECUTED 11fb0c: 74 a8 je 11fab6 <== NOT EXECUTED fclose(fp); 11fb0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fb11: 53 push %ebx <== NOT EXECUTED 11fb12: e8 d5 b0 00 00 call 12abec <== NOT EXECUTED *result = grp; 11fb17: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11fb1a: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11fb1c: 31 c0 xor %eax,%eax <== NOT EXECUTED 11fb1e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 11fb21: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11fb24: 5b pop %ebx <== NOT EXECUTED 11fb25: 5e pop %esi <== NOT EXECUTED 11fb26: 5f pop %edi <== NOT EXECUTED 11fb27: c9 leave <== NOT EXECUTED 11fb28: c3 ret <== NOT EXECUTED 0011f800 : return NULL; return p; } struct group *getgrent() { 11f800: 55 push %ebp <== NOT EXECUTED 11f801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f803: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 11f806: a1 d4 91 15 00 mov 0x1591d4,%eax <== NOT EXECUTED 11f80b: 85 c0 test %eax,%eax <== NOT EXECUTED 11f80d: 74 23 je 11f832 <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 11f80f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f812: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11f817: b9 d8 91 15 00 mov $0x1591d8,%ecx <== NOT EXECUTED 11f81c: ba a0 92 15 00 mov $0x1592a0,%edx <== NOT EXECUTED 11f821: e8 e4 fe ff ff call 11f70a <== NOT EXECUTED 11f826: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f829: ba a0 92 15 00 mov $0x1592a0,%edx <== NOT EXECUTED 11f82e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f830: 75 02 jne 11f834 <== NOT EXECUTED 11f832: 31 d2 xor %edx,%edx <== NOT EXECUTED return NULL; return &grent; } 11f834: 89 d0 mov %edx,%eax <== NOT EXECUTED 11f836: c9 leave <== NOT EXECUTED 11f837: c3 ret <== NOT EXECUTED 0011fb4f : } struct group *getgrgid( gid_t gid ) { 11fb4f: 55 push %ebp <== NOT EXECUTED 11fb50: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fb52: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 11fb55: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fb58: 50 push %eax <== NOT EXECUTED 11fb59: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fb5e: 68 d8 91 15 00 push $0x1591d8 <== NOT EXECUTED 11fb63: 68 a0 92 15 00 push $0x1592a0 <== NOT EXECUTED 11fb68: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 11fb6c: 50 push %eax <== NOT EXECUTED 11fb6d: e8 b7 ff ff ff call 11fb29 <== NOT EXECUTED 11fb72: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fb75: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fb77: 85 c0 test %eax,%eax <== NOT EXECUTED 11fb79: 75 03 jne 11fb7e <== NOT EXECUTED return NULL; return p; 11fb7b: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fb7e: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fb80: c9 leave <== NOT EXECUTED 11fb81: c3 ret <== NOT EXECUTED 0011fb29 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fb29: 55 push %ebp <== NOT EXECUTED 11fb2a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fb2c: 53 push %ebx <== NOT EXECUTED 11fb2d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fb30: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 11fb33: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 11fb37: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11fb3a: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11fb3d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11fb40: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11fb43: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fb46: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11fb48: 5b pop %ebx <== NOT EXECUTED 11fb49: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 11fb4a: e9 28 ff ff ff jmp 11fa77 <== NOT EXECUTED 0011fba7 : } struct group *getgrnam( const char *name ) { 11fba7: 55 push %ebp <== NOT EXECUTED 11fba8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fbaa: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 11fbad: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fbb0: 50 push %eax <== NOT EXECUTED 11fbb1: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fbb6: 68 d8 91 15 00 push $0x1591d8 <== NOT EXECUTED 11fbbb: 68 a0 92 15 00 push $0x1592a0 <== NOT EXECUTED 11fbc0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11fbc3: e8 ba ff ff ff call 11fb82 <== NOT EXECUTED 11fbc8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fbcb: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fbcd: 85 c0 test %eax,%eax <== NOT EXECUTED 11fbcf: 75 03 jne 11fbd4 <== NOT EXECUTED return NULL; return p; 11fbd1: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fbd4: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fbd6: c9 leave <== NOT EXECUTED 11fbd7: c3 ret <== NOT EXECUTED 0011fb82 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fb82: 55 push %ebp <== NOT EXECUTED 11fb83: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fb85: 53 push %ebx <== NOT EXECUTED 11fb86: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11fb89: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fb8c: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 11fb8f: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 11fb92: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 11fb95: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11fb98: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11fb9b: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fb9e: 31 d2 xor %edx,%edx <== NOT EXECUTED } 11fba0: 5b pop %ebx <== NOT EXECUTED 11fba1: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(name, 0, grp, buffer, bufsize, result); 11fba2: e9 d0 fe ff ff jmp 11fa77 <== NOT EXECUTED 0011d450 : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 11d450: 55 push %ebp <== NOT EXECUTED 11d451: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 11d453: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11d458: c9 leave <== NOT EXECUTED 11d459: c3 ret <== NOT EXECUTED 0011fc13 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fc13: 55 push %ebp <== NOT EXECUTED 11fc14: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc16: 57 push %edi <== NOT EXECUTED 11fc17: 56 push %esi <== NOT EXECUTED 11fc18: 53 push %ebx <== NOT EXECUTED 11fc19: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fc1c: 89 c7 mov %eax,%edi <== NOT EXECUTED 11fc1e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 11fc21: 89 ce mov %ecx,%esi <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 11fc23: e8 43 fd ff ff call 11f96b <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 11fc28: 50 push %eax <== NOT EXECUTED 11fc29: 50 push %eax <== NOT EXECUTED 11fc2a: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11fc2f: 68 e1 ce 13 00 push $0x13cee1 <== NOT EXECUTED 11fc34: e8 1f b7 00 00 call 12b358 <== NOT EXECUTED 11fc39: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fc3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fc3e: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc40: 75 10 jne 11fc52 <== NOT EXECUTED errno = EINVAL; 11fc42: e8 59 ae 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11fc47: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11fc4d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fc50: eb 6b jmp 11fcbd <== NOT EXECUTED return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 11fc52: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fc55: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11fc58: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11fc5b: 89 f2 mov %esi,%edx <== NOT EXECUTED 11fc5d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11fc5f: e8 d4 fb ff ff call 11f838 <== NOT EXECUTED 11fc64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fc67: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc69: 75 19 jne 11fc84 <== NOT EXECUTED errno = EINVAL; 11fc6b: e8 30 ae 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11fc70: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 11fc76: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fc79: 53 push %ebx <== NOT EXECUTED 11fc7a: e8 6d af 00 00 call 12abec <== NOT EXECUTED 11fc7f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fc82: eb 36 jmp 11fcba <== NOT EXECUTED return -1; } if (name) { 11fc84: 85 ff test %edi,%edi <== NOT EXECUTED 11fc86: 74 11 je 11fc99 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); 11fc88: 50 push %eax <== NOT EXECUTED 11fc89: 50 push %eax <== NOT EXECUTED 11fc8a: 57 push %edi <== NOT EXECUTED 11fc8b: ff 36 pushl (%esi) <== NOT EXECUTED 11fc8d: e8 5e f2 00 00 call 12eef0 <== NOT EXECUTED 11fc92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fc95: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc97: eb 07 jmp 11fca0 <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); 11fc99: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 11fc9d: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 11fca0: 0f 94 c0 sete %al <== NOT EXECUTED 11fca3: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 11fca6: 85 c0 test %eax,%eax <== NOT EXECUTED 11fca8: 74 a8 je 11fc52 <== NOT EXECUTED fclose(fp); 11fcaa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fcad: 53 push %ebx <== NOT EXECUTED 11fcae: e8 39 af 00 00 call 12abec <== NOT EXECUTED *result = pwd; 11fcb3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11fcb6: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11fcb8: 31 c0 xor %eax,%eax <== NOT EXECUTED 11fcba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 11fcbd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11fcc0: 5b pop %ebx <== NOT EXECUTED 11fcc1: 5e pop %esi <== NOT EXECUTED 11fcc2: 5f pop %edi <== NOT EXECUTED 11fcc3: c9 leave <== NOT EXECUTED 11fcc4: c3 ret <== NOT EXECUTED 0011f933 : return NULL; return p; } struct passwd *getpwent() { 11f933: 55 push %ebp <== NOT EXECUTED 11f934: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f936: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 11f939: a1 ec 90 15 00 mov 0x1590ec,%eax <== NOT EXECUTED 11f93e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f940: 74 23 je 11f965 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 11f942: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f945: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11f94a: b9 f0 90 15 00 mov $0x1590f0,%ecx <== NOT EXECUTED 11f94f: ba b8 91 15 00 mov $0x1591b8,%edx <== NOT EXECUTED 11f954: e8 df fe ff ff call 11f838 <== NOT EXECUTED 11f959: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f95c: ba b8 91 15 00 mov $0x1591b8,%edx <== NOT EXECUTED 11f961: 85 c0 test %eax,%eax <== NOT EXECUTED 11f963: 75 02 jne 11f967 <== NOT EXECUTED 11f965: 31 d2 xor %edx,%edx <== NOT EXECUTED return NULL; return &pwent; } 11f967: 89 d0 mov %edx,%eax <== NOT EXECUTED 11f969: c9 leave <== NOT EXECUTED 11f96a: c3 ret <== NOT EXECUTED 0011fd43 : } struct passwd *getpwnam( const char *name ) { 11fd43: 55 push %ebp <== NOT EXECUTED 11fd44: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fd46: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 11fd49: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fd4c: 50 push %eax <== NOT EXECUTED 11fd4d: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fd52: 68 f0 90 15 00 push $0x1590f0 <== NOT EXECUTED 11fd57: 68 b8 91 15 00 push $0x1591b8 <== NOT EXECUTED 11fd5c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11fd5f: e8 ba ff ff ff call 11fd1e <== NOT EXECUTED 11fd64: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fd67: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fd69: 85 c0 test %eax,%eax <== NOT EXECUTED 11fd6b: 75 03 jne 11fd70 <== NOT EXECUTED return NULL; return p; 11fd6d: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fd70: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fd72: c9 leave <== NOT EXECUTED 11fd73: c3 ret <== NOT EXECUTED 0011fd1e : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fd1e: 55 push %ebp <== NOT EXECUTED 11fd1f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fd21: 53 push %ebx <== NOT EXECUTED 11fd22: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11fd25: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fd28: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 11fd2b: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 11fd2e: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 11fd31: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11fd34: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11fd37: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fd3a: 31 d2 xor %edx,%edx <== NOT EXECUTED } 11fd3c: 5b pop %ebx <== NOT EXECUTED 11fd3d: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(name, 0, pwd, buffer, bufsize, result); 11fd3e: e9 d0 fe ff ff jmp 11fc13 <== NOT EXECUTED 0011fceb : } struct passwd *getpwuid( uid_t uid ) { 11fceb: 55 push %ebp <== NOT EXECUTED 11fcec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fcee: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 11fcf1: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fcf4: 50 push %eax <== NOT EXECUTED 11fcf5: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fcfa: 68 f0 90 15 00 push $0x1590f0 <== NOT EXECUTED 11fcff: 68 b8 91 15 00 push $0x1591b8 <== NOT EXECUTED 11fd04: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 11fd08: 50 push %eax <== NOT EXECUTED 11fd09: e8 b7 ff ff ff call 11fcc5 <== NOT EXECUTED 11fd0e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fd11: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fd13: 85 c0 test %eax,%eax <== NOT EXECUTED 11fd15: 75 03 jne 11fd1a <== NOT EXECUTED return NULL; return p; 11fd17: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fd1a: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fd1c: c9 leave <== NOT EXECUTED 11fd1d: c3 ret <== NOT EXECUTED 0011fcc5 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fcc5: 55 push %ebp <== NOT EXECUTED 11fcc6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fcc8: 53 push %ebx <== NOT EXECUTED 11fcc9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fccc: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 11fccf: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 11fcd3: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11fcd6: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11fcd9: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11fcdc: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11fcdf: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fce2: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11fce4: 5b pop %ebx <== NOT EXECUTED 11fce5: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 11fce6: e9 28 ff ff ff jmp 11fc13 <== NOT EXECUTED 0010cd48 : int gettimeofday( struct timeval *tp, void * __tz ) { 10cd48: 55 push %ebp <== NOT EXECUTED 10cd49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4b: 56 push %esi <== NOT EXECUTED 10cd4c: 53 push %ebx <== NOT EXECUTED 10cd4d: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10cd50: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10cd53: 85 f6 test %esi,%esi <== NOT EXECUTED 10cd55: 75 10 jne 10cd67 <== NOT EXECUTED errno = EFAULT; 10cd57: e8 54 19 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10cd5c: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10cd62: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cd65: eb 2a jmp 10cd91 <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10cd67: 9c pushf <== NOT EXECUTED 10cd68: fa cli <== NOT EXECUTED 10cd69: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10cd6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd6d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10cd70: 50 push %eax <== NOT EXECUTED 10cd71: e8 fa d0 ff ff call 109e70 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 10cd76: 53 push %ebx <== NOT EXECUTED 10cd77: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 10cd78: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cd7b: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 10cd7d: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10cd80: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 10cd85: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd87: f7 f1 div %ecx <== NOT EXECUTED 10cd89: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10cd8c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cd8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; } 10cd91: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cd94: 5b pop %ebx <== NOT EXECUTED 10cd95: 5e pop %esi <== NOT EXECUTED 10cd96: c9 leave <== NOT EXECUTED 10cd97: c3 ret <== NOT EXECUTED 0010a104 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { 10a104: 55 push %ebp <== NOT EXECUTED 10a105: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a107: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 10a10c: 66 8b 40 2a mov 0x2a(%eax),%ax <== NOT EXECUTED return _POSIX_types_Uid; } 10a110: c9 leave <== NOT EXECUTED 10a111: c3 ret <== NOT EXECUTED 00128db7 : */ int imfs_dir_close( rtems_libio_t *iop ) { 128db7: 55 push %ebp <== NOT EXECUTED 128db8: 89 e5 mov %esp,%ebp <== NOT EXECUTED * and associated memory. At present the imfs_dir_close simply * returns a successful completion status. */ return 0; } 128dba: 31 c0 xor %eax,%eax <== NOT EXECUTED 128dbc: c9 leave <== NOT EXECUTED 128dbd: c3 ret <== NOT EXECUTED 00128dbe : int imfs_dir_fstat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 128dbe: 55 push %ebp <== NOT EXECUTED 128dbf: 89 e5 mov %esp,%ebp <== NOT EXECUTED 128dc1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) loc->node_access; 128dc4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 128dc7: 8b 10 mov (%eax),%edx <== NOT EXECUTED buf->st_dev = 0ll; 128dc9: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 128dcf: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 128dd6: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 128dd9: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED buf->st_mode = the_jnode->st_mode; 128ddc: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 128ddf: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 128de2: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 128de5: 66 89 41 10 mov %ax,0x10(%ecx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 128de9: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 128dec: 66 89 41 12 mov %ax,0x12(%ecx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 128df0: 66 8b 42 3e mov 0x3e(%edx),%ax <== NOT EXECUTED 128df4: 66 89 41 14 mov %ax,0x14(%ecx) <== NOT EXECUTED buf->st_rdev = 0ll; 128df8: c7 41 18 00 00 00 00 movl $0x0,0x18(%ecx) <== NOT EXECUTED 128dff: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED buf->st_blksize = 0; 128e06: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED buf->st_blocks = 0; 128e0d: c7 41 40 00 00 00 00 movl $0x0,0x40(%ecx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 128e14: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 128e17: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 128e1a: 8b 42 44 mov 0x44(%edx),%eax <== NOT EXECUTED 128e1d: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 128e20: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 128e23: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED buf->st_size = 0; 128e26: c7 41 20 00 00 00 00 movl $0x0,0x20(%ecx) <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; 128e2d: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 128e30: 83 c2 54 add $0x54,%edx <== NOT EXECUTED 128e33: eb 09 jmp 128e3e <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ) ; the_node = the_node->next ) { buf->st_size = buf->st_size + sizeof( struct dirent ); 128e35: 81 41 20 0c 01 00 00 addl $0x10c,0x20(%ecx) <== NOT EXECUTED /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; !rtems_chain_is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 128e3c: 8b 00 mov (%eax),%eax <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; !rtems_chain_is_tail( the_chain, the_node ) ; 128e3e: 39 d0 cmp %edx,%eax <== NOT EXECUTED 128e40: 75 f3 jne 128e35 <== NOT EXECUTED buf->st_size = buf->st_size + sizeof( struct dirent ); } return 0; } 128e42: 31 c0 xor %eax,%eax <== NOT EXECUTED 128e44: c9 leave <== NOT EXECUTED 128e45: c3 ret <== NOT EXECUTED 00128e46 : off_t imfs_dir_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 128e46: 55 push %ebp <== NOT EXECUTED 128e47: 89 e5 mov %esp,%ebp <== NOT EXECUTED 128e49: 53 push %ebx <== NOT EXECUTED 128e4a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 128e4d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED switch( whence ) { 128e50: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 128e54: 77 19 ja 128e6f <== NOT EXECUTED case SEEK_SET: /* absolute move from the start of the file */ case SEEK_CUR: /* relative move */ iop->offset = (iop->offset/sizeof(struct dirent)) * 128e56: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 128e59: bb 0c 01 00 00 mov $0x10c,%ebx <== NOT EXECUTED 128e5e: 31 d2 xor %edx,%edx <== NOT EXECUTED 128e60: f7 f3 div %ebx <== NOT EXECUTED 128e62: 69 c0 0c 01 00 00 imul $0x10c,%eax,%eax <== NOT EXECUTED 128e68: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED 128e6b: 31 c0 xor %eax,%eax <== NOT EXECUTED 128e6d: eb 0e jmp 128e7d <== NOT EXECUTED break; case SEEK_END: /* Movement past the end of the directory via lseek */ /* is not a permitted operation */ default: rtems_set_errno_and_return_minus_one( EINVAL ); 128e6f: e8 2c 1c 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 128e74: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 128e7a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED break; } return 0; } 128e7d: 5a pop %edx <== NOT EXECUTED 128e7e: 5b pop %ebx <== NOT EXECUTED 128e7f: c9 leave <== NOT EXECUTED 128e80: c3 ret <== NOT EXECUTED 00128d98 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 128d98: 55 push %ebp <== NOT EXECUTED 128d99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 128d9b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) 128d9e: 8b 41 2c mov 0x2c(%ecx),%eax <== NOT EXECUTED 128da1: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 128da4: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 128da8: 75 09 jne 128db3 <== NOT EXECUTED return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 128daa: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 128db1: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 128db3: 89 d0 mov %edx,%eax <== NOT EXECUTED 128db5: c9 leave <== NOT EXECUTED 128db6: c3 ret <== NOT EXECUTED 00128f34 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 128f34: 55 push %ebp <== NOT EXECUTED 128f35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 128f37: 57 push %edi <== NOT EXECUTED 128f38: 56 push %esi <== NOT EXECUTED 128f39: 53 push %ebx <== NOT EXECUTED 128f3a: 81 ec 3c 01 00 00 sub $0x13c,%esp <== NOT EXECUTED int current_entry; int first_entry; int last_entry; struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->file_info; 128f40: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 128f43: 8b 42 2c mov 0x2c(%edx),%eax <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 128f46: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 128f49: 89 b5 c0 fe ff ff mov %esi,-0x140(%ebp) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 128f4f: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 128f52: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; if ( rtems_chain_is_empty( the_chain ) ) 128f58: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 128f5f: 00 00 00 <== NOT EXECUTED 128f62: 39 c6 cmp %eax,%esi <== NOT EXECUTED 128f64: 0f 84 ef 00 00 00 je 129059 <== NOT EXECUTED /* Move to the first of the desired directory entries */ the_node = the_chain->first; bytes_transferred = 0; first_entry = iop->offset; 128f6a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 128f6d: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED 128f70: 89 bd d8 fe ff ff mov %edi,-0x128(%ebp) <== NOT EXECUTED /* protect against using sizes that are not exact multiples of the */ /* -dirent- size. These could result in unexpected results */ last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); 128f76: b9 0c 01 00 00 mov $0x10c,%ecx <== NOT EXECUTED 128f7b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 128f7e: 31 d2 xor %edx,%edx <== NOT EXECUTED 128f80: f7 f1 div %ecx <== NOT EXECUTED 128f82: 69 c0 0c 01 00 00 imul $0x10c,%eax,%eax <== NOT EXECUTED 128f88: 01 f8 add %edi,%eax <== NOT EXECUTED 128f8a: 89 85 dc fe ff ff mov %eax,-0x124(%ebp) <== NOT EXECUTED 128f90: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 128f97: 00 00 00 <== NOT EXECUTED 128f9a: 31 db xor %ebx,%ebx <== NOT EXECUTED tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; tmp_dirent.d_namlen = strlen( the_jnode->name ); strcpy( tmp_dirent.d_name, the_jnode->name ); 128f9c: 8d 95 e8 fe ff ff lea -0x118(%ebp),%edx <== NOT EXECUTED 128fa2: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) <== NOT EXECUTED 128fa8: e9 a0 00 00 00 jmp 12904d <== NOT EXECUTED for ( current_entry = 0; current_entry < last_entry; current_entry = current_entry + sizeof(struct dirent) ){ if ( rtems_chain_is_tail( the_chain, the_node ) ){ 128fad: 8b b5 e0 fe ff ff mov -0x120(%ebp),%esi <== NOT EXECUTED 128fb3: 39 b5 c0 fe ff ff cmp %esi,-0x140(%ebp) <== NOT EXECUTED 128fb9: 0f 84 9a 00 00 00 je 129059 <== NOT EXECUTED /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 128fbf: 3b 9d d8 fe ff ff cmp -0x128(%ebp),%ebx <== NOT EXECUTED 128fc5: 7c 72 jl 129039 <== NOT EXECUTED /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 128fc7: 89 9d ec fe ff ff mov %ebx,-0x114(%ebp) <== NOT EXECUTED tmp_dirent.d_reclen = sizeof( struct dirent ); 128fcd: 66 c7 85 f0 fe ff ff movw $0x10c,-0x110(%ebp) <== NOT EXECUTED 128fd4: 0c 01 <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 128fd6: 8b bd c0 fe ff ff mov -0x140(%ebp),%edi <== NOT EXECUTED 128fdc: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 128fdf: 89 85 e8 fe ff ff mov %eax,-0x118(%ebp) <== NOT EXECUTED tmp_dirent.d_namlen = strlen( the_jnode->name ); 128fe5: 89 fa mov %edi,%edx <== NOT EXECUTED 128fe7: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 128fea: 31 c0 xor %eax,%eax <== NOT EXECUTED 128fec: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 128fef: 89 d7 mov %edx,%edi <== NOT EXECUTED 128ff1: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 128ff3: f7 d1 not %ecx <== NOT EXECUTED 128ff5: 49 dec %ecx <== NOT EXECUTED 128ff6: 66 89 8d f2 fe ff ff mov %cx,-0x10e(%ebp) <== NOT EXECUTED strcpy( tmp_dirent.d_name, the_jnode->name ); 128ffd: 56 push %esi <== NOT EXECUTED 128ffe: 56 push %esi <== NOT EXECUTED 128fff: 52 push %edx <== NOT EXECUTED 129000: 8d 85 f4 fe ff ff lea -0x10c(%ebp),%eax <== NOT EXECUTED 129006: 50 push %eax <== NOT EXECUTED 129007: e8 48 5f 00 00 call 12ef54 <== NOT EXECUTED memcpy( 12900c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 12900f: 03 bd d4 fe ff ff add -0x12c(%ebp),%edi <== NOT EXECUTED 129015: b9 43 00 00 00 mov $0x43,%ecx <== NOT EXECUTED 12901a: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi <== NOT EXECUTED 129020: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 129022: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 129025: 81 47 08 0c 01 00 00 addl $0x10c,0x8(%edi) <== NOT EXECUTED bytes_transferred = bytes_transferred + sizeof( struct dirent ); 12902c: 81 85 d4 fe ff ff 0c addl $0x10c,-0x12c(%ebp) <== NOT EXECUTED 129033: 01 00 00 <== NOT EXECUTED 129036: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } the_node = the_node->next; 129039: 8b 85 c0 fe ff ff mov -0x140(%ebp),%eax <== NOT EXECUTED 12903f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 129041: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp) <== NOT EXECUTED ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 129047: 81 c3 0c 01 00 00 add $0x10c,%ebx <== NOT EXECUTED last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 12904d: 3b 9d dc fe ff ff cmp -0x124(%ebp),%ebx <== NOT EXECUTED 129053: 0f 8c 54 ff ff ff jl 128fad <== NOT EXECUTED the_node = the_node->next; } /* Success */ return bytes_transferred; } 129059: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax <== NOT EXECUTED 12905f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129062: 5b pop %ebx <== NOT EXECUTED 129063: 5e pop %esi <== NOT EXECUTED 129064: 5f pop %edi <== NOT EXECUTED 129065: c9 leave <== NOT EXECUTED 129066: c3 ret <== NOT EXECUTED 00128e81 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 128e81: 55 push %ebp <== NOT EXECUTED 128e82: 89 e5 mov %esp,%ebp <== NOT EXECUTED 128e84: 56 push %esi <== NOT EXECUTED 128e85: 53 push %ebx <== NOT EXECUTED 128e86: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 128e89: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 128e8c: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 128e8e: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 128e91: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 128e94: 74 0d je 128ea3 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 128e96: e8 05 1c 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 128e9b: c7 00 5a 00 00 00 movl $0x5a,(%eax) <== NOT EXECUTED 128ea1: eb 19 jmp 128ebc <== NOT EXECUTED /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 128ea3: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 128ea6: 39 58 18 cmp %ebx,0x18(%eax) <== NOT EXECUTED 128ea9: 74 06 je 128eb1 <== NOT EXECUTED /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 128eab: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) <== NOT EXECUTED 128eaf: 74 10 je 128ec1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); 128eb1: e8 ea 1b 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 128eb6: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 128ebc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 128ebf: eb 6c jmp 128f2d <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 128ec1: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 128ec5: 74 13 je 128eda <== NOT EXECUTED 128ec7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 128eca: 53 push %ebx <== NOT EXECUTED 128ecb: e8 88 52 fe ff call 10e158 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 128ed0: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 128ed7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 128eda: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 128ede: 51 push %ecx <== NOT EXECUTED 128edf: 51 push %ecx <== NOT EXECUTED 128ee0: 6a 00 push $0x0 <== NOT EXECUTED 128ee2: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 128ee5: 50 push %eax <== NOT EXECUTED 128ee6: e8 a9 11 fe ff call 10a094 <== NOT EXECUTED 128eeb: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 128eee: 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) ) { 128ef1: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 128ef4: e8 f7 12 fe ff call 10a1f0 <== NOT EXECUTED 128ef9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 128efc: 85 c0 test %eax,%eax <== NOT EXECUTED 128efe: 75 2b jne 128f2b <== NOT EXECUTED 128f00: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 128f05: 75 24 jne 128f2b <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 128f07: 8b 15 84 3b 14 00 mov 0x143b84,%edx <== NOT EXECUTED 128f0d: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 128f10: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 128f12: 75 07 jne 128f1b <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 128f14: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 128f1b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 128f1e: 53 push %ebx <== NOT EXECUTED 128f1f: e8 f8 10 fe ff call 10a01c <== NOT EXECUTED 128f24: 31 c0 xor %eax,%eax <== NOT EXECUTED 128f26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 128f29: eb 02 jmp 128f2d <== NOT EXECUTED 128f2b: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 128f2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 128f30: 5b pop %ebx <== NOT EXECUTED 128f31: 5e pop %esi <== NOT EXECUTED 128f32: c9 leave <== NOT EXECUTED 128f33: c3 ret <== NOT EXECUTED 0011f96b : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 11f96b: 55 push %ebp <== NOT EXECUTED 11f96c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f96e: 53 push %ebx <== NOT EXECUTED 11f96f: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 11f972: 80 3d e8 90 15 00 00 cmpb $0x0,0x1590e8 <== NOT EXECUTED 11f979: 0f 85 b8 00 00 00 jne 11fa37 <== NOT EXECUTED return; etc_passwd_initted = 1; 11f97f: c6 05 e8 90 15 00 01 movb $0x1,0x1590e8 <== NOT EXECUTED mkdir("/etc", 0777); 11f986: 51 push %ecx <== NOT EXECUTED 11f987: 51 push %ecx <== NOT EXECUTED 11f988: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 11f98d: 68 dc ce 13 00 push $0x13cedc <== NOT EXECUTED 11f992: e8 81 ac fe ff call 10a618 <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 11f997: 58 pop %eax <== NOT EXECUTED 11f998: 5a pop %edx <== NOT EXECUTED 11f999: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11f99e: 68 e1 ce 13 00 push $0x13cee1 <== NOT EXECUTED 11f9a3: e8 b0 b9 00 00 call 12b358 <== NOT EXECUTED 11f9a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f9ab: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9ad: 74 06 je 11f9b5 <== NOT EXECUTED fclose(fp); 11f9af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f9b2: 50 push %eax <== NOT EXECUTED 11f9b3: eb 2a jmp 11f9df <== NOT EXECUTED } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 11f9b5: 50 push %eax <== NOT EXECUTED 11f9b6: 50 push %eax <== NOT EXECUTED 11f9b7: 68 ea ae 13 00 push $0x13aeea <== NOT EXECUTED 11f9bc: 68 e1 ce 13 00 push $0x13cee1 <== NOT EXECUTED 11f9c1: e8 92 b9 00 00 call 12b358 <== NOT EXECUTED 11f9c6: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f9c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f9cb: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9cd: 74 18 je 11f9e7 <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 11f9cf: 50 push %eax <== NOT EXECUTED 11f9d0: 50 push %eax <== NOT EXECUTED 11f9d1: 53 push %ebx <== NOT EXECUTED 11f9d2: 68 ed ce 13 00 push $0x13ceed <== NOT EXECUTED 11f9d7: e8 a4 ba 00 00 call 12b480 <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 11f9dc: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11f9df: e8 08 b2 00 00 call 12abec <== NOT EXECUTED 11f9e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 11f9e7: 53 push %ebx <== NOT EXECUTED 11f9e8: 53 push %ebx <== NOT EXECUTED 11f9e9: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11f9ee: 68 54 cf 13 00 push $0x13cf54 <== NOT EXECUTED 11f9f3: e8 60 b9 00 00 call 12b358 <== NOT EXECUTED 11f9f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f9fb: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9fd: 74 06 je 11fa05 <== NOT EXECUTED fclose(fp); 11f9ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fa02: 50 push %eax <== NOT EXECUTED 11fa03: eb 2a jmp 11fa2f <== NOT EXECUTED } else if ((fp = fopen("/etc/group", "w")) != NULL) { 11fa05: 51 push %ecx <== NOT EXECUTED 11fa06: 51 push %ecx <== NOT EXECUTED 11fa07: 68 ea ae 13 00 push $0x13aeea <== NOT EXECUTED 11fa0c: 68 54 cf 13 00 push $0x13cf54 <== NOT EXECUTED 11fa11: e8 42 b9 00 00 call 12b358 <== NOT EXECUTED 11fa16: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fa18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fa1b: 85 c0 test %eax,%eax <== NOT EXECUTED 11fa1d: 74 18 je 11fa37 <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 11fa1f: 52 push %edx <== NOT EXECUTED 11fa20: 52 push %edx <== NOT EXECUTED 11fa21: 50 push %eax <== NOT EXECUTED 11fa22: 68 5f cf 13 00 push $0x13cf5f <== NOT EXECUTED 11fa27: e8 54 ba 00 00 call 12b480 <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 11fa2c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11fa2f: e8 b8 b1 00 00 call 12abec <== NOT EXECUTED 11fa34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 11fa37: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11fa3a: c9 leave <== NOT EXECUTED 11fa3b: c3 ret <== NOT EXECUTED 0010cfe8 : * This routine will initialize the chain control element that manages the * mount table chain. */ int init_fs_mount_table(void) { 10cfe8: 55 push %ebp <== NOT EXECUTED 10cfe9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfeb: c7 05 9c cc 11 00 a0 movl $0x11cca0,0x11cc9c <== NOT EXECUTED 10cff2: cc 11 00 <== NOT EXECUTED 10cff5: c7 05 a0 cc 11 00 00 movl $0x0,0x11cca0 <== NOT EXECUTED 10cffc: 00 00 00 <== NOT EXECUTED 10cfff: c7 05 a4 cc 11 00 9c movl $0x11cc9c,0x11cca4 <== NOT EXECUTED 10d006: cc 11 00 <== NOT EXECUTED rtems_chain_initialize_empty ( &rtems_filesystem_mount_table_control ); return 0; } 10d009: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d00b: c9 leave <== NOT EXECUTED 10d00c: c3 ret <== NOT EXECUTED 00114ce4 : int ioctl( int fd, ioctl_command_t command, ... ) { 114ce4: 55 push %ebp <== NOT EXECUTED 114ce5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ce7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED va_list ap; rtems_status_code rc; rtems_libio_t *iop; void *buffer; rtems_libio_check_fd( fd ); 114ced: 3b 05 78 33 12 00 cmp 0x123378,%eax <== NOT EXECUTED 114cf3: 73 19 jae 114d0e <== NOT EXECUTED iop = rtems_libio_iop( fd ); 114cf5: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 114cf8: 03 05 24 87 12 00 add 0x128724,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 114cfe: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 114d02: 74 0a je 114d0e <== NOT EXECUTED va_start(ap, command); buffer = va_arg(ap, void *); 114d04: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) 114d07: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 114d0a: 85 d2 test %edx,%edx <== NOT EXECUTED 114d0c: 75 0d jne 114d1b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 114d0e: e8 95 05 00 00 call 1152a8 <__errno> <== NOT EXECUTED 114d13: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 114d19: eb 12 jmp 114d2d <== NOT EXECUTED if ( !iop->handlers->ioctl_h ) 114d1b: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 114d1e: 85 d2 test %edx,%edx <== NOT EXECUTED 114d20: 75 10 jne 114d32 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 114d22: e8 81 05 00 00 call 1152a8 <__errno> <== NOT EXECUTED 114d27: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 114d2d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114d30: eb 0d jmp 114d3f <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 114d32: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 114d35: 51 push %ecx <== NOT EXECUTED 114d36: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114d39: 50 push %eax <== NOT EXECUTED 114d3a: ff d2 call *%edx <== NOT EXECUTED 114d3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 114d3f: c9 leave <== NOT EXECUTED 114d40: c3 ret <== NOT EXECUTED 00107a50 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 107a50: 55 push %ebp <== NOT EXECUTED 107a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107a53: 56 push %esi <== NOT EXECUTED 107a54: 53 push %ebx <== NOT EXECUTED 107a55: 89 d6 mov %edx,%esi <== NOT EXECUTED 107a57: 88 c3 mov %al,%bl <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 107a59: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 107a5c: f6 c1 20 test $0x20,%cl <== NOT EXECUTED 107a5f: 74 03 je 107a64 <== NOT EXECUTED c &= 0x7f; 107a61: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 107a64: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 107a67: 74 13 je 107a7c <== NOT EXECUTED c = tolower (c); 107a69: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED 107a6c: a1 b8 a9 11 00 mov 0x11a9b8,%eax <== NOT EXECUTED 107a71: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED 107a75: 74 03 je 107a7a <== NOT EXECUTED 107a77: 83 c2 20 add $0x20,%edx <== NOT EXECUTED 107a7a: 88 d3 mov %dl,%bl <== NOT EXECUTED if (c == '\r') { 107a7c: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED 107a7f: 75 11 jne 107a92 <== NOT EXECUTED if (tty->termios.c_iflag & IGNCR) 107a81: 84 c9 test %cl,%cl <== NOT EXECUTED 107a83: 0f 88 c9 00 00 00 js 107b52 <== NOT EXECUTED return 0; if (tty->termios.c_iflag & ICRNL) 107a89: 80 e5 01 and $0x1,%ch <== NOT EXECUTED 107a8c: 74 1c je 107aaa <== NOT EXECUTED 107a8e: b3 0a mov $0xa,%bl <== NOT EXECUTED 107a90: eb 18 jmp 107aaa <== NOT EXECUTED c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 107a92: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 107a95: 75 0b jne 107aa2 <== NOT EXECUTED 107a97: 80 e1 40 and $0x40,%cl <== NOT EXECUTED 107a9a: 0f 85 b8 00 00 00 jne 107b58 <== NOT EXECUTED 107aa0: eb 08 jmp 107aaa <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 107aa2: 84 db test %bl,%bl <== NOT EXECUTED 107aa4: 0f 84 80 00 00 00 je 107b2a <== NOT EXECUTED 107aaa: 8b 56 3c mov 0x3c(%esi),%edx <== NOT EXECUTED 107aad: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 107ab0: 74 78 je 107b2a <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 107ab2: 3a 5e 43 cmp 0x43(%esi),%bl <== NOT EXECUTED 107ab5: 75 04 jne 107abb <== NOT EXECUTED erase (tty, 0); 107ab7: 31 d2 xor %edx,%edx <== NOT EXECUTED 107ab9: eb 0a jmp 107ac5 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VKILL]) { 107abb: 3a 5e 44 cmp 0x44(%esi),%bl <== NOT EXECUTED 107abe: 75 11 jne 107ad1 <== NOT EXECUTED erase (tty, 1); 107ac0: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 107ac5: 89 f0 mov %esi,%eax <== NOT EXECUTED 107ac7: e8 17 fe ff ff call 1078e3 <== NOT EXECUTED 107acc: e9 81 00 00 00 jmp 107b52 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VEOF]) { 107ad1: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 107ad6: 3a 5e 45 cmp 0x45(%esi),%bl <== NOT EXECUTED 107ad9: 74 79 je 107b54 <== NOT EXECUTED return 1; } else if (c == '\n') { 107adb: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 107ade: 75 1d jne 107afd <== NOT EXECUTED if (tty->termios.c_lflag & (ECHO | ECHONL)) 107ae0: 80 e2 48 and $0x48,%dl <== NOT EXECUTED 107ae3: 74 0c je 107af1 <== NOT EXECUTED echo (c, tty); 107ae5: 89 f2 mov %esi,%edx <== NOT EXECUTED 107ae7: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 107aec: e8 9a fd ff ff call 10788b <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107af1: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107af4: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107af7: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED 107afb: eb 22 jmp 107b1f <== NOT EXECUTED return 1; } else if ((c == tty->termios.c_cc[VEOL]) 107afd: 3a 5e 4c cmp 0x4c(%esi),%bl <== NOT EXECUTED 107b00: 74 05 je 107b07 <== NOT EXECUTED 107b02: 3a 5e 51 cmp 0x51(%esi),%bl <== NOT EXECUTED 107b05: 75 23 jne 107b2a <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 107b07: 80 e2 08 and $0x8,%dl <== NOT EXECUTED 107b0a: 74 0a je 107b16 <== NOT EXECUTED echo (c, tty); 107b0c: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107b0f: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b11: e8 75 fd ff ff call 10788b <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107b16: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107b19: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107b1c: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 107b1f: 40 inc %eax <== NOT EXECUTED 107b20: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 107b23: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 107b28: eb 2a jmp 107b54 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 107b2a: a1 3c a9 11 00 mov 0x11a93c,%eax <== NOT EXECUTED 107b2f: 48 dec %eax <== NOT EXECUTED 107b30: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107b33: 7d 1d jge 107b52 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 107b35: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED 107b39: 74 0a je 107b45 <== NOT EXECUTED echo (c, tty); 107b3b: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107b3e: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b40: e8 46 fd ff ff call 10788b <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107b45: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107b48: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107b4b: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 107b4e: 40 inc %eax <== NOT EXECUTED 107b4f: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 107b52: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 107b54: 5b pop %ebx <== NOT EXECUTED 107b55: 5e pop %esi <== NOT EXECUTED 107b56: c9 leave <== NOT EXECUTED 107b57: c3 ret <== 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; 107b58: b3 0d mov $0xd,%bl <== NOT EXECUTED 107b5a: e9 4b ff ff ff jmp 107aaa <== NOT EXECUTED 00114b6c : #include int isatty( int fd ) { 114b6c: 55 push %ebp <== NOT EXECUTED 114b6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114b6f: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat buf; if (fstat (fd, &buf) < 0) 114b72: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 114b75: 50 push %eax <== NOT EXECUTED 114b76: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114b79: e8 4a ff ff ff call 114ac8 <== NOT EXECUTED 114b7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114b81: 31 d2 xor %edx,%edx <== NOT EXECUTED 114b83: 85 c0 test %eax,%eax <== NOT EXECUTED 114b85: 78 12 js 114b99 <== NOT EXECUTED 114b87: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 114b8a: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 114b8f: 31 d2 xor %edx,%edx <== NOT EXECUTED 114b91: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 114b96: 0f 94 c2 sete %dl <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 114b99: 89 d0 mov %edx,%eax <== NOT EXECUTED 114b9b: c9 leave <== NOT EXECUTED 114b9c: c3 ret <== NOT EXECUTED 0011d55c : * These are directly supported (and completely correct) in the posix api. */ #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { 11d55c: 55 push %ebp <== NOT EXECUTED 11d55d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11d55f: 31 c0 xor %eax,%eax <== NOT EXECUTED 11d561: c9 leave <== NOT EXECUTED 11d562: c3 ret <== NOT EXECUTED 001068ce : */ bool libc_create_hook( rtems_tcb *current_task, rtems_tcb *creating_task ) { 1068ce: 55 push %ebp <== NOT EXECUTED 1068cf: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1068d1: 57 push %edi <== NOT EXECUTED 1068d2: 56 push %esi <== NOT EXECUTED 1068d3: 53 push %ebx <== NOT EXECUTED 1068d4: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ptr = (struct _reent *) calloc(1, sizeof(struct _reent)); #else /* It is OK to allocate from the workspace because these * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); 1068d7: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1068dc: e8 7c 54 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 1068e1: 89 c3 mov %eax,%ebx <== NOT EXECUTED #endif if (ptr) { 1068e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1068e6: 31 c0 xor %eax,%eax <== NOT EXECUTED 1068e8: 85 db test %ebx,%ebx <== NOT EXECUTED 1068ea: 0f 84 2a 02 00 00 je 106b1a <== NOT EXECUTED _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 1068f0: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 1068f6: 8d 93 ec 02 00 00 lea 0x2ec(%ebx),%edx <== NOT EXECUTED 1068fc: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 1068ff: 8d 83 48 03 00 00 lea 0x348(%ebx),%eax <== NOT EXECUTED 106905: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 106908: 8d 83 a4 03 00 00 lea 0x3a4(%ebx),%eax <== NOT EXECUTED 10690e: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 106911: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 106918: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10691b: be 19 00 00 00 mov $0x19,%esi <== NOT EXECUTED 106920: 31 c0 xor %eax,%eax <== NOT EXECUTED 106922: 89 f1 mov %esi,%ecx <== NOT EXECUTED 106924: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 106926: 89 ce mov %ecx,%esi <== NOT EXECUTED 106928: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED 10692f: c7 43 34 80 67 11 00 movl $0x116780,0x34(%ebx) <== NOT EXECUTED 106936: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED 10693d: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx) <== NOT EXECUTED 106944: c7 43 40 00 00 00 00 movl $0x0,0x40(%ebx) <== NOT EXECUTED 10694b: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED 106952: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED 106959: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx) <== NOT EXECUTED 106960: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 106967: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10696e: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED 106975: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 10697c: c6 43 60 00 movb $0x0,0x60(%ebx) <== NOT EXECUTED 106980: 8d 7b 7c lea 0x7c(%ebx),%edi <== NOT EXECUTED 106983: b1 09 mov $0x9,%cl <== NOT EXECUTED 106985: 89 f0 mov %esi,%eax <== NOT EXECUTED 106987: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 106989: c7 83 a0 00 00 00 00 movl $0x0,0xa0(%ebx) <== NOT EXECUTED 106990: 00 00 00 <== NOT EXECUTED 106993: c7 83 a4 00 00 00 01 movl $0x1,0xa4(%ebx) <== NOT EXECUTED 10699a: 00 00 00 <== NOT EXECUTED 10699d: c7 83 a8 00 00 00 00 movl $0x0,0xa8(%ebx) <== NOT EXECUTED 1069a4: 00 00 00 <== NOT EXECUTED 1069a7: 66 c7 83 ac 00 00 00 movw $0x330e,0xac(%ebx) <== NOT EXECUTED 1069ae: 0e 33 <== NOT EXECUTED 1069b0: 66 c7 83 ae 00 00 00 movw $0xabcd,0xae(%ebx) <== NOT EXECUTED 1069b7: cd ab <== NOT EXECUTED 1069b9: 66 c7 83 b0 00 00 00 movw $0x1234,0xb0(%ebx) <== NOT EXECUTED 1069c0: 34 12 <== NOT EXECUTED 1069c2: 66 c7 83 b2 00 00 00 movw $0xe66d,0xb2(%ebx) <== NOT EXECUTED 1069c9: 6d e6 <== NOT EXECUTED 1069cb: 66 c7 83 b4 00 00 00 movw $0xdeec,0xb4(%ebx) <== NOT EXECUTED 1069d2: ec de <== NOT EXECUTED 1069d4: 66 c7 83 b6 00 00 00 movw $0x5,0xb6(%ebx) <== NOT EXECUTED 1069db: 05 00 <== NOT EXECUTED 1069dd: 66 c7 83 b8 00 00 00 movw $0xb,0xb8(%ebx) <== NOT EXECUTED 1069e4: 0b 00 <== NOT EXECUTED 1069e6: c7 83 bc 00 00 00 00 movl $0x0,0xbc(%ebx) <== NOT EXECUTED 1069ed: 00 00 00 <== NOT EXECUTED 1069f0: c7 83 c0 00 00 00 00 movl $0x0,0xc0(%ebx) <== NOT EXECUTED 1069f7: 00 00 00 <== NOT EXECUTED 1069fa: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 106a01: 00 00 00 <== NOT EXECUTED 106a04: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 106a0b: 00 00 00 <== NOT EXECUTED 106a0e: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx) <== NOT EXECUTED 106a15: 00 00 00 <== NOT EXECUTED 106a18: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 106a1f: 00 00 00 <== NOT EXECUTED 106a22: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx) <== NOT EXECUTED 106a29: 00 00 00 <== NOT EXECUTED 106a2c: c7 83 fc 00 00 00 00 movl $0x0,0xfc(%ebx) <== NOT EXECUTED 106a33: 00 00 00 <== NOT EXECUTED 106a36: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) <== NOT EXECUTED 106a3d: 00 00 00 <== NOT EXECUTED 106a40: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 106a47: 00 00 00 <== NOT EXECUTED 106a4a: c7 83 08 01 00 00 00 movl $0x0,0x108(%ebx) <== NOT EXECUTED 106a51: 00 00 00 <== NOT EXECUTED 106a54: c7 83 0c 01 00 00 00 movl $0x0,0x10c(%ebx) <== NOT EXECUTED 106a5b: 00 00 00 <== NOT EXECUTED 106a5e: c7 83 10 01 00 00 00 movl $0x0,0x110(%ebx) <== NOT EXECUTED 106a65: 00 00 00 <== NOT EXECUTED 106a68: c7 83 14 01 00 00 00 movl $0x0,0x114(%ebx) <== NOT EXECUTED 106a6f: 00 00 00 <== NOT EXECUTED 106a72: c7 83 18 01 00 00 00 movl $0x0,0x118(%ebx) <== NOT EXECUTED 106a79: 00 00 00 <== NOT EXECUTED 106a7c: c7 83 1c 01 00 00 00 movl $0x0,0x11c(%ebx) <== NOT EXECUTED 106a83: 00 00 00 <== NOT EXECUTED 106a86: c6 83 d4 00 00 00 00 movb $0x0,0xd4(%ebx) <== NOT EXECUTED 106a8d: c6 83 dc 00 00 00 00 movb $0x0,0xdc(%ebx) <== NOT EXECUTED 106a94: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) <== NOT EXECUTED 106a9b: 00 00 00 <== NOT EXECUTED 106a9e: c7 83 48 01 00 00 00 movl $0x0,0x148(%ebx) <== NOT EXECUTED 106aa5: 00 00 00 <== NOT EXECUTED 106aa8: c7 83 4c 01 00 00 00 movl $0x0,0x14c(%ebx) <== NOT EXECUTED 106aaf: 00 00 00 <== NOT EXECUTED 106ab2: c7 83 50 01 00 00 00 movl $0x0,0x150(%ebx) <== NOT EXECUTED 106ab9: 00 00 00 <== NOT EXECUTED 106abc: c7 83 54 01 00 00 00 movl $0x0,0x154(%ebx) <== NOT EXECUTED 106ac3: 00 00 00 <== NOT EXECUTED 106ac6: c7 83 d4 02 00 00 00 movl $0x0,0x2d4(%ebx) <== NOT EXECUTED 106acd: 00 00 00 <== NOT EXECUTED 106ad0: c7 83 d4 01 00 00 00 movl $0x0,0x1d4(%ebx) <== NOT EXECUTED 106ad7: 00 00 00 <== NOT EXECUTED 106ada: c7 83 dc 02 00 00 00 movl $0x0,0x2dc(%ebx) <== NOT EXECUTED 106ae1: 00 00 00 <== NOT EXECUTED 106ae4: c7 83 e0 02 00 00 00 movl $0x0,0x2e0(%ebx) <== NOT EXECUTED 106aeb: 00 00 00 <== NOT EXECUTED 106aee: c7 83 e4 02 00 00 00 movl $0x0,0x2e4(%ebx) <== NOT EXECUTED 106af5: 00 00 00 <== NOT EXECUTED 106af8: c7 83 e8 02 00 00 00 movl $0x0,0x2e8(%ebx) <== NOT EXECUTED 106aff: 00 00 00 <== NOT EXECUTED 106b02: c7 45 e8 45 00 00 00 movl $0x45,-0x18(%ebp) <== NOT EXECUTED 106b09: 89 d7 mov %edx,%edi <== NOT EXECUTED 106b0b: b1 45 mov $0x45,%cl <== NOT EXECUTED 106b0d: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED creating_task->libc_reent = ptr; 106b0f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106b12: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax) <== NOT EXECUTED 106b18: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } else return false; } 106b1a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106b1d: 5b pop %ebx <== NOT EXECUTED 106b1e: 5e pop %esi <== NOT EXECUTED 106b1f: 5f pop %edi <== NOT EXECUTED 106b20: c9 leave <== NOT EXECUTED 106b21: c3 ret <== NOT EXECUTED 00106818 : rtems_extension libc_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 106818: 55 push %ebp <== NOT EXECUTED 106819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10681b: 57 push %edi <== NOT EXECUTED 10681c: 56 push %esi <== NOT EXECUTED 10681d: 53 push %ebx <== NOT EXECUTED 10681e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106821: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106824: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 106827: 39 f7 cmp %esi,%edi <== NOT EXECUTED 106829: 75 08 jne 106833 <== NOT EXECUTED ptr = _REENT; 10682b: 8b 1d c0 a9 11 00 mov 0x11a9c0,%ebx <== NOT EXECUTED 106831: eb 06 jmp 106839 <== NOT EXECUTED } else { ptr = deleted_task->libc_reent; 106833: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx <== NOT EXECUTED } if (ptr && ptr != &libc_global_reent) { 106839: 85 db test %ebx,%ebx <== NOT EXECUTED 10683b: 74 20 je 10685d <== NOT EXECUTED 10683d: 81 fb 38 a5 11 00 cmp $0x11a538,%ebx <== NOT EXECUTED 106843: 74 18 je 10685d <== NOT EXECUTED _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 106845: 50 push %eax <== NOT EXECUTED 106846: 50 push %eax <== NOT EXECUTED 106847: 68 7d 68 10 00 push $0x10687d <== NOT EXECUTED 10684c: 53 push %ebx <== NOT EXECUTED 10684d: e8 16 85 00 00 call 10ed68 <_fwalk> <== NOT EXECUTED #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 106852: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 106855: e8 ee 54 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10685a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif } deleted_task->libc_reent = NULL; 10685d: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi) <== NOT EXECUTED 106864: 00 00 00 <== NOT EXECUTED /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 106867: 39 f7 cmp %esi,%edi <== NOT EXECUTED 106869: 75 0a jne 106875 <== NOT EXECUTED _REENT = 0; 10686b: c7 05 c0 a9 11 00 00 movl $0x0,0x11a9c0 <== NOT EXECUTED 106872: 00 00 00 <== NOT EXECUTED } } 106875: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106878: 5b pop %ebx <== NOT EXECUTED 106879: 5e pop %esi <== NOT EXECUTED 10687a: 5f pop %edi <== NOT EXECUTED 10687b: c9 leave <== NOT EXECUTED 10687c: c3 ret <== NOT EXECUTED 001067fc : struct _reent libc_global_reent __ATTRIBUTE_IMPURE_PTR__ = _REENT_INIT(libc_global_reent); void libc_init(void) { 1067fc: 55 push %ebp <== NOT EXECUTED 1067fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED _REENT = &libc_global_reent; 1067ff: c7 05 c0 a9 11 00 38 movl $0x11a538,0x11a9c0 <== NOT EXECUTED 106806: a5 11 00 <== NOT EXECUTED 106809: c7 05 88 ca 11 00 c0 movl $0x11a9c0,0x11ca88 <== NOT EXECUTED 106810: a9 11 00 <== NOT EXECUTED _Thread_Set_libc_reent (&_REENT); } 106813: c9 leave <== NOT EXECUTED 106814: c3 ret <== NOT EXECUTED 00114c64 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 114c64: 55 push %ebp <== NOT EXECUTED 114c65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114c67: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 114c6a: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 114c71: 75 55 jne 114cc8 <== NOT EXECUTED /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 114c73: 81 3d c0 a9 11 00 38 cmpl $0x11a538,0x11a9c0 <== NOT EXECUTED 114c7a: a5 11 00 <== NOT EXECUTED 114c7d: 74 1a je 114c99 <== NOT EXECUTED _wrapup_reent(&libc_global_reent); 114c7f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114c82: 68 38 a5 11 00 push $0x11a538 <== NOT EXECUTED 114c87: e8 b8 05 00 00 call 115244 <_wrapup_reent> <== NOT EXECUTED /* Don't reclaim this one, just in case we do printfs * on the way out to ROM. */ _reclaim_reent(&libc_global_reent); #endif _REENT = &libc_global_reent; 114c8c: c7 05 c0 a9 11 00 38 movl $0x11a538,0x11a9c0 <== NOT EXECUTED 114c93: a5 11 00 <== NOT EXECUTED 114c96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 114c99: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114c9c: a1 c0 a9 11 00 mov 0x11a9c0,%eax <== NOT EXECUTED 114ca1: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 114ca4: e8 53 9b ff ff call 10e7fc <== NOT EXECUTED fclose (stdout); 114ca9: 5a pop %edx <== NOT EXECUTED 114caa: a1 c0 a9 11 00 mov 0x11a9c0,%eax <== NOT EXECUTED 114caf: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 114cb2: e8 45 9b ff ff call 10e7fc <== NOT EXECUTED fclose (stderr); 114cb7: 58 pop %eax <== NOT EXECUTED 114cb8: a1 c0 a9 11 00 mov 0x11a9c0,%eax <== NOT EXECUTED 114cbd: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 114cc0: e8 37 9b ff ff call 10e7fc <== NOT EXECUTED 114cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 114cc8: c9 leave <== NOT EXECUTED 114cc9: c3 ret <== NOT EXECUTED 0011fe08 : int link( const char *existing, const char *new ) { 11fe08: 55 push %ebp <== NOT EXECUTED 11fe09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fe0b: 57 push %edi <== NOT EXECUTED 11fe0c: 56 push %esi <== NOT EXECUTED 11fe0d: 53 push %ebx <== NOT EXECUTED 11fe0e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 11fe11: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, true ); 11fe14: 6a 01 push $0x1 <== NOT EXECUTED 11fe16: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11fe19: 50 push %eax <== NOT EXECUTED 11fe1a: 6a 00 push $0x0 <== NOT EXECUTED 11fe1c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11fe1f: e8 d6 a0 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 11fe24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fe27: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 11fe2a: 85 c0 test %eax,%eax <== NOT EXECUTED 11fe2c: 0f 85 7a 01 00 00 jne 11ffac <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 11fe32: 8a 03 mov (%ebx),%al <== NOT EXECUTED 11fe34: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 11fe36: 74 08 je 11fe40 <== NOT EXECUTED 11fe38: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 11fe3a: 74 04 je 11fe40 <== NOT EXECUTED 11fe3c: 84 c0 test %al,%al <== NOT EXECUTED 11fe3e: 75 16 jne 11fe56 <== NOT EXECUTED 11fe40: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11fe43: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11fe48: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 11fe4b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11fe50: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11fe52: b1 01 mov $0x1,%cl <== NOT EXECUTED 11fe54: eb 12 jmp 11fe68 <== NOT EXECUTED 11fe56: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11fe59: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 11fe5e: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 11fe61: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11fe66: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !parent_loc.ops->evalformake_h ) { 11fe68: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11fe6b: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 11fe6e: 85 d2 test %edx,%edx <== NOT EXECUTED 11fe70: 75 21 jne 11fe93 <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11fe72: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11fe75: 85 c0 test %eax,%eax <== NOT EXECUTED 11fe77: 0f 84 de 00 00 00 je 11ff5b <== NOT EXECUTED 11fe7d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11fe80: 85 d2 test %edx,%edx <== NOT EXECUTED 11fe82: 0f 84 d3 00 00 00 je 11ff5b <== NOT EXECUTED 11fe88: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fe8b: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11fe8e: e9 c2 00 00 00 jmp 11ff55 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 11fe93: 56 push %esi <== NOT EXECUTED 11fe94: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11fe97: 50 push %eax <== NOT EXECUTED 11fe98: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11fe9b: 57 push %edi <== NOT EXECUTED 11fe9c: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED 11fe9f: 50 push %eax <== NOT EXECUTED 11fea0: ff d2 call *%edx <== NOT EXECUTED 11fea2: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 11fea4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fea7: 85 c0 test %eax,%eax <== NOT EXECUTED 11fea9: 74 29 je 11fed4 <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11feab: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11feae: 85 c0 test %eax,%eax <== NOT EXECUTED 11feb0: 74 13 je 11fec5 <== NOT EXECUTED 11feb2: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11feb5: 85 d2 test %edx,%edx <== NOT EXECUTED 11feb7: 74 0c je 11fec5 <== NOT EXECUTED 11feb9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11febc: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11febf: 50 push %eax <== NOT EXECUTED 11fec0: ff d2 call *%edx <== NOT EXECUTED 11fec2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 11fec5: e8 d6 ab 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11feca: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11fecc: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 11fecf: e9 d8 00 00 00 jmp 11ffac <== NOT EXECUTED /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 11fed4: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11fed7: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 11feda: 74 41 je 11ff1d <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11fedc: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11fedf: 85 c0 test %eax,%eax <== NOT EXECUTED 11fee1: 74 13 je 11fef6 <== NOT EXECUTED 11fee3: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11fee6: 85 d2 test %edx,%edx <== NOT EXECUTED 11fee8: 74 0c je 11fef6 <== NOT EXECUTED 11feea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11feed: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11fef0: 50 push %eax <== NOT EXECUTED 11fef1: ff d2 call *%edx <== NOT EXECUTED 11fef3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 11fef6: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11fef9: 85 c0 test %eax,%eax <== NOT EXECUTED 11fefb: 74 13 je 11ff10 <== NOT EXECUTED 11fefd: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff00: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff02: 74 0c je 11ff10 <== NOT EXECUTED 11ff04: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff07: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 11ff0a: 50 push %eax <== NOT EXECUTED 11ff0b: ff d2 call *%edx <== NOT EXECUTED 11ff0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 11ff10: e8 8b ab 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ff15: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 11ff1b: eb af jmp 11fecc <== NOT EXECUTED } if ( !parent_loc.ops->link_h ) { 11ff1d: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ff20: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 11ff23: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff25: 75 44 jne 11ff6b <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ff27: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ff2a: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff2c: 74 13 je 11ff41 <== NOT EXECUTED 11ff2e: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff31: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff33: 74 0c je 11ff41 <== NOT EXECUTED 11ff35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff38: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11ff3b: 50 push %eax <== NOT EXECUTED 11ff3c: ff d2 call *%edx <== NOT EXECUTED 11ff3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 11ff41: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ff44: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff46: 74 13 je 11ff5b <== NOT EXECUTED 11ff48: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff4b: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff4d: 74 0c je 11ff5b <== NOT EXECUTED 11ff4f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff52: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 11ff55: 50 push %eax <== NOT EXECUTED 11ff56: ff d2 call *%edx <== NOT EXECUTED 11ff58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ff5b: e8 40 ab 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 11ff60: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ff66: e9 61 ff ff ff jmp 11fecc <== NOT EXECUTED } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 11ff6b: 52 push %edx <== NOT EXECUTED 11ff6c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 11ff6f: 57 push %edi <== NOT EXECUTED 11ff70: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 11ff73: 57 push %edi <== NOT EXECUTED 11ff74: ff d0 call *%eax <== NOT EXECUTED 11ff76: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ff78: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ff7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ff7e: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff80: 74 10 je 11ff92 <== NOT EXECUTED 11ff82: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ff85: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff87: 74 09 je 11ff92 <== NOT EXECUTED 11ff89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff8c: 57 push %edi <== NOT EXECUTED 11ff8d: ff d0 call *%eax <== NOT EXECUTED 11ff8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 11ff92: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ff95: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff97: 74 13 je 11ffac <== NOT EXECUTED 11ff99: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff9c: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff9e: 74 0c je 11ffac <== NOT EXECUTED 11ffa0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ffa3: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 11ffa6: 50 push %eax <== NOT EXECUTED 11ffa7: ff d2 call *%edx <== NOT EXECUTED 11ffa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 11ffac: 89 f0 mov %esi,%eax <== NOT EXECUTED 11ffae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11ffb1: 5b pop %ebx <== NOT EXECUTED 11ffb2: 5e pop %esi <== NOT EXECUTED 11ffb3: 5f pop %edi <== NOT EXECUTED 11ffb4: c9 leave <== NOT EXECUTED 11ffb5: c3 ret <== NOT EXECUTED 00114ba0 : off_t lseek( int fd, off_t offset, int whence ) { 114ba0: 55 push %ebp <== NOT EXECUTED 114ba1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ba3: 56 push %esi <== NOT EXECUTED 114ba4: 53 push %ebx <== NOT EXECUTED 114ba5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ba8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 114bab: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 114bae: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 114bb4: 73 0f jae 114bc5 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 114bb6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 114bb9: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 114bbf: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 114bc3: 75 0d jne 114bd2 <== NOT EXECUTED 114bc5: e8 e6 9a ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114bca: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 114bd0: eb 46 jmp 114c18 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 114bd2: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 114bd5: 83 78 14 00 cmpl $0x0,0x14(%eax) <== NOT EXECUTED 114bd9: 75 0d jne 114be8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 114bdb: e8 d0 9a ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114be0: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 114be6: eb 30 jmp 114c18 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 114be8: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED switch ( whence ) { 114beb: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 114bee: 74 0e je 114bfe <== NOT EXECUTED 114bf0: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 114bf3: 74 0e je 114c03 <== NOT EXECUTED 114bf5: 85 d2 test %edx,%edx <== NOT EXECUTED 114bf7: 75 14 jne 114c0d <== NOT EXECUTED case SEEK_SET: iop->offset = offset; 114bf9: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 114bfc: eb 1f jmp 114c1d <== NOT EXECUTED break; case SEEK_CUR: iop->offset += offset; 114bfe: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 114c01: eb 05 jmp 114c08 <== NOT EXECUTED break; case SEEK_END: iop->offset = iop->size + offset; 114c03: 89 c8 mov %ecx,%eax <== NOT EXECUTED 114c05: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 114c08: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 114c0b: eb 10 jmp 114c1d <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 114c0d: e8 9e 9a ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114c12: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 114c18: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114c1b: eb 15 jmp 114c32 <== NOT EXECUTED /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 114c1d: 50 push %eax <== NOT EXECUTED 114c1e: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 114c21: 52 push %edx <== NOT EXECUTED 114c22: 51 push %ecx <== NOT EXECUTED 114c23: 53 push %ebx <== NOT EXECUTED 114c24: ff 50 14 call *0x14(%eax) <== NOT EXECUTED if ( status == (off_t) -1 ) 114c27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c2a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 114c2d: 75 03 jne 114c32 <== NOT EXECUTED iop->offset = old_offset; 114c2f: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 114c32: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114c35: 5b pop %ebx <== NOT EXECUTED 114c36: 5e pop %esi <== NOT EXECUTED 114c37: c9 leave <== NOT EXECUTED 114c38: c3 ret <== NOT EXECUTED 00120080 : int _STAT_NAME( const char *path, struct stat *buf ) { 120080: 55 push %ebp <== NOT EXECUTED 120081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120083: 57 push %edi <== NOT EXECUTED 120084: 56 push %esi <== NOT EXECUTED 120085: 53 push %ebx <== NOT EXECUTED 120086: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 120089: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 12008d: 75 0d jne 12009c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 12008f: e8 0c aa 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120094: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 12009a: eb 45 jmp 1200e1 <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 12009c: 6a 00 push $0x0 <== NOT EXECUTED 12009e: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 1200a1: 56 push %esi <== NOT EXECUTED 1200a2: 6a 00 push $0x0 <== NOT EXECUTED 1200a4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1200a7: e8 4e 9e fe ff call 109efa <== NOT EXECUTED if ( status != 0 ) 1200ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1200af: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1200b2: 85 c0 test %eax,%eax <== NOT EXECUTED 1200b4: 75 5f jne 120115 <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 1200b6: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1200b9: 83 7a 18 00 cmpl $0x0,0x18(%edx) <== NOT EXECUTED 1200bd: 75 27 jne 1200e6 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1200bf: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1200c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1200c4: 74 10 je 1200d6 <== NOT EXECUTED 1200c6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1200c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1200cb: 74 09 je 1200d6 <== NOT EXECUTED 1200cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1200d0: 56 push %esi <== NOT EXECUTED 1200d1: ff d0 call *%eax <== NOT EXECUTED 1200d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1200d6: e8 c5 a9 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1200db: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1200e1: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1200e4: eb 2f jmp 120115 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 1200e6: b9 13 00 00 00 mov $0x13,%ecx <== NOT EXECUTED 1200eb: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 1200ee: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 1200f0: 50 push %eax <== NOT EXECUTED 1200f1: 50 push %eax <== NOT EXECUTED 1200f2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1200f5: 56 push %esi <== NOT EXECUTED 1200f6: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 1200f9: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1200fb: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1200fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120101: 85 c0 test %eax,%eax <== NOT EXECUTED 120103: 74 10 je 120115 <== NOT EXECUTED 120105: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120108: 85 c0 test %eax,%eax <== NOT EXECUTED 12010a: 74 09 je 120115 <== NOT EXECUTED 12010c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12010f: 56 push %esi <== NOT EXECUTED 120110: ff d0 call *%eax <== NOT EXECUTED 120112: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 120115: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120117: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12011a: 5b pop %ebx <== NOT EXECUTED 12011b: 5e pop %esi <== NOT EXECUTED 12011c: 5f pop %edi <== NOT EXECUTED 12011d: c9 leave <== NOT EXECUTED 12011e: c3 ret <== NOT EXECUTED 00106664 : size_t size ) { void *return_this; MSBUMP(malloc_calls, 1); 106664: 55 push %ebp <== NOT EXECUTED 106665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106667: 56 push %esi <== NOT EXECUTED 106668: 53 push %ebx <== NOT EXECUTED 106669: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10666c: ff 05 14 c9 11 00 incl 0x11c914 <== NOT EXECUTED /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 106672: e8 48 ff ff ff call 1065bf <== NOT EXECUTED /* * Validate the parameters */ if ( !size ) 106677: 85 f6 test %esi,%esi <== NOT EXECUTED 106679: 74 75 je 1066f0 <== 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()) && 10667b: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 106682: 75 09 jne 10668d <== NOT EXECUTED 106684: e8 df fe ff ff call 106568 <== NOT EXECUTED 106689: 84 c0 test %al,%al <== NOT EXECUTED 10668b: 74 63 je 1066f0 <== NOT EXECUTED * Try to give a segment in the current heap if there is not * enough space then try to grow the heap. * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 10668d: 51 push %ecx <== NOT EXECUTED 10668e: 51 push %ecx <== NOT EXECUTED 10668f: 56 push %esi <== NOT EXECUTED 106690: 68 b8 c8 11 00 push $0x11c8b8 <== NOT EXECUTED 106695: e8 d2 41 00 00 call 10a86c <_Protected_heap_Allocate> <== NOT EXECUTED 10669a: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !return_this ) { 10669c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10669f: 85 c0 test %eax,%eax <== NOT EXECUTED 1066a1: 75 26 jne 1066c9 <== NOT EXECUTED if (rtems_malloc_sbrk_helpers) 1066a3: a1 78 ae 11 00 mov 0x11ae78,%eax <== NOT EXECUTED 1066a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1066aa: 74 0e je 1066ba <== NOT EXECUTED return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 1066ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1066af: 56 push %esi <== NOT EXECUTED 1066b0: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( !return_this ) { 1066b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1066b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1066b8: 75 0d jne 1066c7 <== NOT EXECUTED errno = ENOMEM; 1066ba: e8 f1 7f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 1066bf: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1066c5: eb 2b jmp 1066f2 <== NOT EXECUTED return (void *) 0; 1066c7: 89 c3 mov %eax,%ebx <== NOT EXECUTED } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 1066c9: a1 7c ae 11 00 mov 0x11ae7c,%eax <== NOT EXECUTED 1066ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1066d0: 74 09 je 1066db <== NOT EXECUTED (*rtems_malloc_dirty_helper)( return_this, size ); 1066d2: 52 push %edx <== NOT EXECUTED 1066d3: 52 push %edx <== NOT EXECUTED 1066d4: 56 push %esi <== NOT EXECUTED 1066d5: 53 push %ebx <== NOT EXECUTED 1066d6: ff d0 call *%eax <== NOT EXECUTED 1066d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1066db: a1 74 ae 11 00 mov 0x11ae74,%eax <== NOT EXECUTED 1066e0: 85 c0 test %eax,%eax <== NOT EXECUTED 1066e2: 74 0e je 1066f2 <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 1066e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1066e7: 53 push %ebx <== NOT EXECUTED 1066e8: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 1066eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1066ee: eb 02 jmp 1066f2 <== NOT EXECUTED 1066f0: 31 db xor %ebx,%ebx <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 1066f2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1066f4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1066f7: 5b pop %ebx <== NOT EXECUTED 1066f8: 5e pop %esi <== NOT EXECUTED 1066f9: c9 leave <== NOT EXECUTED 1066fa: c3 ret <== NOT EXECUTED 001065a7 : } void malloc_deferred_free( void *pointer ) { 1065a7: 55 push %ebp <== NOT EXECUTED 1065a8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1065aa: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1065ad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1065b0: 68 ac c8 11 00 push $0x11c8ac <== NOT EXECUTED 1065b5: e8 66 34 00 00 call 109a20 <_Chain_Append> <== NOT EXECUTED 1065ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer); } 1065bd: c9 leave <== NOT EXECUTED 1065be: c3 ret <== NOT EXECUTED 00106584 : void malloc_deferred_frees_initialize(void) { 106584: 55 push %ebp <== NOT EXECUTED 106585: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106587: c7 05 ac c8 11 00 b0 movl $0x11c8b0,0x11c8ac <== NOT EXECUTED 10658e: c8 11 00 <== NOT EXECUTED 106591: c7 05 b0 c8 11 00 00 movl $0x0,0x11c8b0 <== NOT EXECUTED 106598: 00 00 00 <== NOT EXECUTED 10659b: c7 05 b4 c8 11 00 ac movl $0x11c8ac,0x11c8b4 <== NOT EXECUTED 1065a2: c8 11 00 <== NOT EXECUTED rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } 1065a5: c9 leave <== NOT EXECUTED 1065a6: c3 ret <== NOT EXECUTED 001065bf : { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) { 1065bf: 55 push %ebp <== NOT EXECUTED 1065c0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1065c2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1065c5: eb 0c jmp 1065d3 <== NOT EXECUTED /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) free(to_be_freed); 1065c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1065ca: 50 push %eax <== NOT EXECUTED 1065cb: e8 98 fe ff ff call 106468 <== NOT EXECUTED 1065d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1065d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1065d6: 68 ac c8 11 00 push $0x11c8ac <== NOT EXECUTED 1065db: e8 64 34 00 00 call 109a44 <_Chain_Get> <== NOT EXECUTED rtems_chain_node *to_be_freed; /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) 1065e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1065e3: 85 c0 test %eax,%eax <== NOT EXECUTED 1065e5: 75 e0 jne 1065c7 <== NOT EXECUTED free(to_be_freed); } 1065e7: c9 leave <== NOT EXECUTED 1065e8: c3 ret <== NOT EXECUTED 0010a448 : /* * Find amount of free heap remaining */ size_t malloc_free_space( void ) { 10a448: 55 push %ebp <== NOT EXECUTED 10a449: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a44b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Information info; _Protected_heap_Get_free_information( &RTEMS_Malloc_Heap, &info ); 10a44e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a451: 50 push %eax <== NOT EXECUTED 10a452: 68 a0 9a 15 00 push $0x159aa0 <== NOT EXECUTED 10a457: e8 80 4f 00 00 call 10f3dc <_Protected_heap_Get_free_information> <== NOT EXECUTED 10a45c: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED return (size_t) info.largest; } 10a45f: c9 leave <== NOT EXECUTED 10a460: c3 ret <== NOT EXECUTED 00120134 : */ int malloc_info( Heap_Information_block *the_info ) { 120134: 55 push %ebp <== NOT EXECUTED 120135: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120137: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12013a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_info ) 12013d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 120140: 85 d2 test %edx,%edx <== NOT EXECUTED 120142: 74 12 je 120156 <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); 120144: 50 push %eax <== NOT EXECUTED 120145: 50 push %eax <== NOT EXECUTED 120146: 52 push %edx <== NOT EXECUTED 120147: 68 a0 9a 15 00 push $0x159aa0 <== NOT EXECUTED 12014c: e8 e3 1c 00 00 call 121e34 <_Protected_heap_Get_information> <== NOT EXECUTED 120151: 31 c0 xor %eax,%eax <== NOT EXECUTED 120153: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 120156: c9 leave <== NOT EXECUTED 120157: c3 ret <== NOT EXECUTED 00106568 : #include "malloc_p.h" rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { 106568: 55 push %ebp <== NOT EXECUTED 106569: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _Thread_Dispatch_disable_level > 0 ) 10656b: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 106570: 31 d2 xor %edx,%edx <== NOT EXECUTED 106572: 85 c0 test %eax,%eax <== NOT EXECUTED 106574: 75 0a jne 106580 <== NOT EXECUTED return false; if ( _ISR_Nest_level > 0 ) 106576: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 10657b: 85 c0 test %eax,%eax <== NOT EXECUTED 10657d: 0f 94 c2 sete %dl <== NOT EXECUTED return false; return true; } 106580: 88 d0 mov %dl,%al <== NOT EXECUTED 106582: c9 leave <== NOT EXECUTED 106583: c3 ret <== NOT EXECUTED 001079d8 : #ifdef RTEMS_NEWLIB #include "malloc_p.h" void malloc_report_statistics(void) { 1079d8: 55 push %ebp <== NOT EXECUTED 1079d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1079db: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED malloc_report_statistics_with_plugin( NULL, printk_plugin ); 1079de: 68 c4 84 10 00 push $0x1084c4 <== NOT EXECUTED 1079e3: 6a 00 push $0x0 <== NOT EXECUTED 1079e5: e8 06 00 00 00 call 1079f0 <== NOT EXECUTED 1079ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1079ed: c9 leave <== NOT EXECUTED 1079ee: c3 ret <== NOT EXECUTED 00120158 : void malloc_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 120158: 55 push %ebp <== NOT EXECUTED 120159: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12015b: 57 push %edi <== NOT EXECUTED 12015c: 56 push %esi <== NOT EXECUTED 12015d: 53 push %ebx <== NOT EXECUTED 12015e: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED rtems_malloc_statistics_t *s; uint32_t allocated; s = &rtems_malloc_statistics; allocated = s->lifetime_allocated - s->lifetime_freed; 120161: 8b 0d 14 9b 15 00 mov 0x159b14,%ecx <== NOT EXECUTED 120167: 8b 1d 18 9b 15 00 mov 0x159b18,%ebx <== NOT EXECUTED 12016d: a1 1c 9b 15 00 mov 0x159b1c,%eax <== NOT EXECUTED 120172: 8b 15 20 9b 15 00 mov 0x159b20,%edx <== NOT EXECUTED 120178: 89 ce mov %ecx,%esi <== NOT EXECUTED 12017a: 29 c6 sub %eax,%esi <== NOT EXECUTED 12017c: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (*print)( 12017f: 8b 3d 10 9b 15 00 mov 0x159b10,%edi <== NOT EXECUTED 120185: 8b 35 f8 9a 15 00 mov 0x159af8,%esi <== NOT EXECUTED 12018b: 0f ac d0 0a shrd $0xa,%edx,%eax <== NOT EXECUTED 12018f: c1 ea 0a shr $0xa,%edx <== NOT EXECUTED 120192: 50 push %eax <== NOT EXECUTED 120193: 0f ac d9 0a shrd $0xa,%ebx,%ecx <== NOT EXECUTED 120197: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 12019a: 51 push %ecx <== NOT EXECUTED 12019b: 6b c7 64 imul $0x64,%edi,%eax <== NOT EXECUTED 12019e: 31 d2 xor %edx,%edx <== NOT EXECUTED 1201a0: f7 f6 div %esi <== NOT EXECUTED 1201a2: 50 push %eax <== NOT EXECUTED 1201a3: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 1201a6: 57 push %edi <== NOT EXECUTED 1201a7: 6b 45 f0 64 imul $0x64,-0x10(%ebp),%eax <== NOT EXECUTED 1201ab: 31 d2 xor %edx,%edx <== NOT EXECUTED 1201ad: f7 f6 div %esi <== NOT EXECUTED 1201af: 50 push %eax <== NOT EXECUTED 1201b0: c1 6d f0 0a shrl $0xa,-0x10(%ebp) <== NOT EXECUTED 1201b4: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1201b7: c1 ee 0a shr $0xa,%esi <== NOT EXECUTED 1201ba: 56 push %esi <== NOT EXECUTED 1201bb: 68 8a cf 13 00 push $0x13cf8a <== NOT EXECUTED 1201c0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1201c3: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED s->max_depth / 1024, (s->max_depth * 100) / s->space_available, (uint32_t) (s->lifetime_allocated / 1024), (uint32_t) (s->lifetime_freed / 1024) ); (*print)( 1201c6: 83 c4 28 add $0x28,%esp <== NOT EXECUTED 1201c9: ff 35 0c 9b 15 00 pushl 0x159b0c <== NOT EXECUTED 1201cf: ff 35 08 9b 15 00 pushl 0x159b08 <== NOT EXECUTED 1201d5: ff 35 04 9b 15 00 pushl 0x159b04 <== NOT EXECUTED 1201db: ff 35 fc 9a 15 00 pushl 0x159afc <== NOT EXECUTED 1201e1: 68 ec cf 13 00 push $0x13cfec <== NOT EXECUTED 1201e6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1201e9: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 1201ec: 83 c4 20 add $0x20,%esp <== NOT EXECUTED s->malloc_calls, s->free_calls, s->realloc_calls, s->calloc_calls ); } 1201ef: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1201f2: 5b pop %ebx <== NOT EXECUTED 1201f3: 5e pop %esi <== NOT EXECUTED 1201f4: 5f pop %edi <== NOT EXECUTED 1201f5: c9 leave <== NOT EXECUTED 1201f6: c3 ret <== NOT EXECUTED 00107a90 : #include "malloc_p.h" #include void malloc_walk(size_t source, size_t printf_enabled) { 107a90: 55 push %ebp <== NOT EXECUTED 107a91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107a93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Protected_heap_Walk( &RTEMS_Malloc_Heap, source, printf_enabled ); 107a96: 31 c0 xor %eax,%eax <== NOT EXECUTED 107a98: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 107a9c: 0f 95 c0 setne %al <== NOT EXECUTED 107a9f: 50 push %eax <== NOT EXECUTED 107aa0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107aa3: 68 e4 07 12 00 push $0x1207e4 <== NOT EXECUTED 107aa8: e8 a3 4c 00 00 call 10c750 <_Protected_heap_Walk> <== NOT EXECUTED 107aad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107ab0: c9 leave <== NOT EXECUTED 107ab1: c3 ret <== NOT EXECUTED 00123df8 : */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) { 123df8: 55 push %ebp <== NOT EXECUTED 123df9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123dfb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK); 123dfe: ff 35 98 69 14 00 pushl 0x146998 <== NOT EXECUTED 123e04: 6a 01 push $0x1 <== NOT EXECUTED 123e06: e8 11 5f fe ff call 109d1c <== NOT EXECUTED if ( memory ) 123e0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123e0e: 85 c0 test %eax,%eax <== NOT EXECUTED 123e10: 74 06 je 123e18 <== NOT EXECUTED memfile_blocks_allocated++; 123e12: ff 05 b0 92 15 00 incl 0x1592b0 <== NOT EXECUTED return memory; } 123e18: c9 leave <== NOT EXECUTED 123e19: c3 ret <== NOT EXECUTED 00124182 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 124182: 55 push %ebp <== NOT EXECUTED 124183: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124185: 53 push %ebx <== NOT EXECUTED 124186: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 124189: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 12418c: 53 push %ebx <== NOT EXECUTED 12418d: e8 5e 60 fe ff call 10a1f0 <== NOT EXECUTED 124192: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124195: 85 c0 test %eax,%eax <== NOT EXECUTED 124197: 75 36 jne 1241cf <== NOT EXECUTED 124199: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 12419e: 75 2f jne 1241cf <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 1241a0: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 1241a5: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1241a8: 75 07 jne 1241b1 <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 1241aa: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 1241b1: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 1241b5: 74 0c je 1241c3 <== NOT EXECUTED IMFS_memfile_remove( the_jnode ); 1241b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1241ba: 53 push %ebx <== NOT EXECUTED 1241bb: e8 7b fe ff ff call 12403b <== NOT EXECUTED 1241c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( the_jnode ); 1241c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1241c6: 53 push %ebx <== NOT EXECUTED 1241c7: e8 50 5e fe ff call 10a01c <== NOT EXECUTED 1241cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 1241cf: 31 c0 xor %eax,%eax <== NOT EXECUTED 1241d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1241d4: c9 leave <== NOT EXECUTED 1241d5: c3 ret <== NOT EXECUTED 0012421f : */ int memfile_close( rtems_libio_t *iop ) { 12421f: 55 push %ebp <== NOT EXECUTED 124220: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124222: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124225: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124228: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED if (iop->flags & LIBIO_FLAGS_APPEND) 12422b: f6 42 0d 02 testb $0x2,0xd(%edx) <== NOT EXECUTED 12422f: 74 06 je 124237 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 124231: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 124234: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED memfile_check_rmnod( the_jnode ); 124237: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12423a: 51 push %ecx <== NOT EXECUTED 12423b: e8 42 ff ff ff call 124182 <== NOT EXECUTED return 0; } 124240: 31 c0 xor %eax,%eax <== NOT EXECUTED 124242: c9 leave <== NOT EXECUTED 124243: c3 ret <== NOT EXECUTED 00123ddf : */ void memfile_free_block( void *memory ) { 123ddf: 55 push %ebp <== NOT EXECUTED 123de0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123de2: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #if 0 fprintf(stdout, "(d %p) ", memory ); fflush(stdout); #endif free(memory); 123de5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123de8: e8 2f 62 fe ff call 10a01c <== NOT EXECUTED memfile_blocks_allocated--; 123ded: ff 0d b0 92 15 00 decl 0x1592b0 <== NOT EXECUTED 123df3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 123df6: c9 leave <== NOT EXECUTED 123df7: c3 ret <== NOT EXECUTED 00123fd1 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 123fd1: 55 push %ebp <== NOT EXECUTED 123fd2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123fd4: 57 push %edi <== NOT EXECUTED 123fd5: 56 push %esi <== NOT EXECUTED 123fd6: 53 push %ebx <== NOT EXECUTED 123fd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123fda: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 123fdd: 85 f6 test %esi,%esi <== NOT EXECUTED 123fdf: 75 19 jne 123ffa <== NOT EXECUTED 123fe1: 68 0d d2 13 00 push $0x13d20d <== NOT EXECUTED 123fe6: 68 f8 d2 13 00 push $0x13d2f8 <== NOT EXECUTED 123feb: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED 123ff0: 68 a0 d1 13 00 push $0x13d1a0 <== NOT EXECUTED 123ff5: e8 ca 5c fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 123ffa: 8b 3e mov (%esi),%edi <== NOT EXECUTED 123ffc: 31 db xor %ebx,%ebx <== NOT EXECUTED 123ffe: eb 1b jmp 12401b <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED memfile_free_block( b[i] ); 124007: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12400a: 50 push %eax <== NOT EXECUTED 12400b: e8 cf fd ff ff call 123ddf <== NOT EXECUTED b[i] = 0; 124010: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4) <== NOT EXECUTED 124017: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i <== NOT EXECUTED /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 124020: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124023: ff 36 pushl (%esi) <== NOT EXECUTED 124025: e8 b5 fd ff ff call 123ddf <== NOT EXECUTED *block_table = 0; 12402a: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 124030: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 124033: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124036: 5b pop %ebx <== NOT EXECUTED 124037: 5e pop %esi <== NOT EXECUTED 124038: 5f pop %edi <== NOT EXECUTED 124039: c9 leave <== NOT EXECUTED 12403a: c3 ret <== NOT EXECUTED 00124386 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 124386: 55 push %ebp <== NOT EXECUTED 124387: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124389: 53 push %ebx <== NOT EXECUTED 12438a: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 12438d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124390: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124393: 8b 5a 2c mov 0x2c(%edx),%ebx <== NOT EXECUTED * POSIX 1003.1b does not specify what happens if you truncate a file * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) 124396: 3b 43 50 cmp 0x50(%ebx),%eax <== NOT EXECUTED 124399: 7e 0b jle 1243a6 <== NOT EXECUTED return IMFS_memfile_extend( the_jnode, length ); 12439b: 52 push %edx <== NOT EXECUTED 12439c: 52 push %edx <== NOT EXECUTED 12439d: 50 push %eax <== NOT EXECUTED 12439e: 53 push %ebx <== NOT EXECUTED 12439f: e8 0f ff ff ff call 1242b3 <== NOT EXECUTED 1243a4: eb 1b jmp 1243c1 <== NOT EXECUTED * The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length; 1243a6: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 1243a9: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 1243ac: 50 push %eax <== NOT EXECUTED 1243ad: 50 push %eax <== NOT EXECUTED 1243ae: 6a 00 push $0x0 <== NOT EXECUTED 1243b0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1243b3: 50 push %eax <== NOT EXECUTED 1243b4: e8 db 5c fe ff call 10a094 <== NOT EXECUTED 1243b9: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1243bc: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED 1243bf: 31 c0 xor %eax,%eax <== NOT EXECUTED 1243c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1243c4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1243c7: c9 leave <== NOT EXECUTED 1243c8: c3 ret <== NOT EXECUTED 00123dd8 : int memfile_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 123dd8: 55 push %ebp <== NOT EXECUTED 123dd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return 0; } 123ddb: 31 c0 xor %eax,%eax <== NOT EXECUTED 123ddd: c9 leave <== NOT EXECUTED 123dde: c3 ret <== NOT EXECUTED 001243c9 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 1243c9: 55 push %ebp <== NOT EXECUTED 1243ca: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1243cc: 56 push %esi <== NOT EXECUTED 1243cd: 53 push %ebx <== NOT EXECUTED 1243ce: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1243d1: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED if (the_jnode->type == IMFS_LINEAR_FILE) { 1243d4: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 1243d8: 75 0d jne 1243e7 <== NOT EXECUTED if (iop->offset > the_jnode->info.linearfile.size) 1243da: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 1243dd: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED 1243e0: 7e 2d jle 12440f <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 1243e2: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 1243e5: eb 28 jmp 12440f <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 1243e7: 51 push %ecx <== NOT EXECUTED 1243e8: 51 push %ecx <== NOT EXECUTED 1243e9: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 1243ec: 53 push %ebx <== NOT EXECUTED 1243ed: e8 c1 fe ff ff call 1242b3 <== NOT EXECUTED 1243f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1243f5: 85 c0 test %eax,%eax <== NOT EXECUTED 1243f7: 74 10 je 124409 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1243f9: e8 a2 66 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1243fe: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 124404: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 124407: eb 09 jmp 124412 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124409: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 12440c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED } return iop->offset; 12440f: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED } 124412: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124415: 5b pop %ebx <== NOT EXECUTED 124416: 5e pop %esi <== NOT EXECUTED 124417: c9 leave <== NOT EXECUTED 124418: c3 ret <== NOT EXECUTED 00124610 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 124610: 55 push %ebp <== NOT EXECUTED 124611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124613: 56 push %esi <== NOT EXECUTED 124614: 53 push %ebx <== NOT EXECUTED 124615: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124618: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 12461b: f7 46 0c 04 02 00 00 testl $0x204,0xc(%esi) <== NOT EXECUTED 124622: 74 46 je 12466a <== NOT EXECUTED 124624: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 124628: 75 40 jne 12466a <== NOT EXECUTED && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 12462a: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 12462d: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 124630: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 124637: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 12463e: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 124645: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 12464c: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED if ((count != 0) 124653: 85 c0 test %eax,%eax <== NOT EXECUTED 124655: 74 13 je 12466a <== NOT EXECUTED 124657: 50 push %eax <== NOT EXECUTED 124658: 52 push %edx <== NOT EXECUTED 124659: 6a 00 push $0x0 <== NOT EXECUTED 12465b: 53 push %ebx <== NOT EXECUTED 12465c: e8 b8 fd ff ff call 124419 <== NOT EXECUTED 124661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124664: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 124667: 40 inc %eax <== NOT EXECUTED 124668: 74 14 je 12467e <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 12466a: f6 46 0d 02 testb $0x2,0xd(%esi) <== NOT EXECUTED 12466e: 74 06 je 124676 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 124670: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124673: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124676: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124679: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 12467c: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 12467e: 89 d0 mov %edx,%eax <== NOT EXECUTED 124680: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124683: 5b pop %ebx <== NOT EXECUTED 124684: 5e pop %esi <== NOT EXECUTED 124685: c9 leave <== NOT EXECUTED 124686: c3 ret <== NOT EXECUTED 0012488f : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 12488f: 55 push %ebp <== NOT EXECUTED 124890: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124892: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124895: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return IMFS_memfile_read( the_jnode, iop->offset, buffer, count ); 124898: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 12489b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12489e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1248a1: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 1248a4: e8 de fd ff ff call 124687 <== NOT EXECUTED } 1248a9: c9 leave <== NOT EXECUTED 1248aa: c3 ret <== NOT EXECUTED 001241d6 : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 1241d6: 55 push %ebp <== NOT EXECUTED 1241d7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1241d9: 53 push %ebx <== NOT EXECUTED 1241da: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 1241dd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1241e0: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 1241e2: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 1241e6: 74 13 je 1241fb <== NOT EXECUTED 1241e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1241eb: 53 push %ebx <== NOT EXECUTED 1241ec: e8 67 9f fe ff call 10e158 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 1241f1: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 1241f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 1241fb: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 1241ff: 50 push %eax <== NOT EXECUTED 124200: 50 push %eax <== NOT EXECUTED 124201: 6a 00 push $0x0 <== NOT EXECUTED 124203: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 124206: 50 push %eax <== NOT EXECUTED 124207: e8 88 5e fe ff call 10a094 <== NOT EXECUTED 12420c: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12420f: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return memfile_check_rmnod( the_jnode ); 124212: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 124215: e8 68 ff ff ff call 124182 <== NOT EXECUTED } 12421a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 12421d: c9 leave <== NOT EXECUTED 12421e: c3 ret <== NOT EXECUTED 001245e9 : ssize_t memfile_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 1245e9: 55 push %ebp <== NOT EXECUTED 1245ea: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1245ec: 56 push %esi <== NOT EXECUTED 1245ed: 53 push %ebx <== NOT EXECUTED 1245ee: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; ssize_t status; the_jnode = iop->file_info; 1245f1: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count ); 1245f4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1245f7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1245fa: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1245fd: 56 push %esi <== NOT EXECUTED 1245fe: e8 16 fe ff ff call 124419 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124603: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 124606: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED return status; } 124609: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12460c: 5b pop %ebx <== NOT EXECUTED 12460d: 5e pop %esi <== NOT EXECUTED 12460e: c9 leave <== NOT EXECUTED 12460f: c3 ret <== NOT EXECUTED 0010c148 : */ int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10c148: 55 push %ebp <== NOT EXECUTED 10c149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c14b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 10c14e: 68 c0 c7 11 00 push $0x11c7c0 <== NOT EXECUTED 10c153: 68 c0 c7 11 00 push $0x11c7c0 <== NOT EXECUTED 10c158: 68 9c 6a 11 00 push $0x116a9c <== NOT EXECUTED 10c15d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c160: e8 f7 06 00 00 call 10c85c <== NOT EXECUTED temp_mt_entry, &miniIMFS_ops, &rtems_filesystem_null_handlers, /* for memfiles */ &rtems_filesystem_null_handlers /* for directories */ ); } 10c165: c9 leave <== NOT EXECUTED 10c166: c3 ret <== NOT EXECUTED 0010cfcc : int mkdir( const char *pathname, mode_t mode ) { 10cfcc: 55 push %ebp <== NOT EXECUTED 10cfcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfcf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cfd2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( pathname, mode | S_IFDIR, 0LL); 10cfd5: 6a 00 push $0x0 <== NOT EXECUTED 10cfd7: 6a 00 push $0x0 <== NOT EXECUTED 10cfd9: 80 cc 40 or $0x40,%ah <== NOT EXECUTED 10cfdc: 50 push %eax <== NOT EXECUTED 10cfdd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cfe0: e8 17 97 ff ff call 1066fc <== NOT EXECUTED } 10cfe5: c9 leave <== NOT EXECUTED 10cfe6: c3 ret <== NOT EXECUTED 001201f8 : int mkfifo( const char *path, mode_t mode ) { 1201f8: 55 push %ebp <== NOT EXECUTED 1201f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1201fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1201fe: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( path, mode | S_IFIFO, 0LL ); 120201: 6a 00 push $0x0 <== NOT EXECUTED 120203: 6a 00 push $0x0 <== NOT EXECUTED 120205: 80 cc 10 or $0x10,%ah <== NOT EXECUTED 120208: 50 push %eax <== NOT EXECUTED 120209: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12020c: e8 23 a4 fe ff call 10a634 <== NOT EXECUTED } 120211: c9 leave <== NOT EXECUTED 120212: c3 ret <== NOT EXECUTED 001066fc : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 1066fc: 55 push %ebp <== NOT EXECUTED 1066fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1066ff: 57 push %edi <== NOT EXECUTED 106700: 56 push %esi <== NOT EXECUTED 106701: 53 push %ebx <== NOT EXECUTED 106702: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 106705: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 106708: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10670b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10670e: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 106711: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED rtems_filesystem_location_info_t temp_loc; int i; const char *name_start; int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) 106714: 89 d8 mov %ebx,%eax <== NOT EXECUTED 106716: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10671b: 75 0d jne 10672a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10671d: e8 8e 7f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106722: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106728: eb 12 jmp 10673c <== NOT EXECUTED if ( S_ISFIFO(mode) ) 10672a: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED 10672f: 75 13 jne 106744 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106731: e8 7a 7f 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106736: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10673c: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10673f: e9 ad 00 00 00 jmp 1067f1 <== NOT EXECUTED rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 106744: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 106747: 8a 02 mov (%edx),%al <== NOT EXECUTED 106749: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10674b: 74 08 je 106755 <== NOT EXECUTED 10674d: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10674f: 74 04 je 106755 <== NOT EXECUTED 106751: 84 c0 test %al,%al <== NOT EXECUTED 106753: 75 16 jne 10676b <== NOT EXECUTED 106755: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 106758: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10675d: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 106760: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106765: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 106767: b1 01 mov $0x1,%cl <== NOT EXECUTED 106769: eb 12 jmp 10677d <== NOT EXECUTED 10676b: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10676e: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 106773: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 106776: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10677b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !temp_loc.ops->evalformake_h ) { 10677d: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 106780: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 106783: 85 d2 test %edx,%edx <== NOT EXECUTED 106785: 74 aa je 106731 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 106787: 50 push %eax <== NOT EXECUTED 106788: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10678b: 50 push %eax <== NOT EXECUTED 10678c: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10678f: 57 push %edi <== NOT EXECUTED 106790: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 106793: 01 c8 add %ecx,%eax <== NOT EXECUTED 106795: 50 push %eax <== NOT EXECUTED 106796: ff d2 call *%edx <== NOT EXECUTED &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 106798: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10679b: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10679e: 85 c0 test %eax,%eax <== NOT EXECUTED 1067a0: 75 4f jne 1067f1 <== NOT EXECUTED return -1; if ( !temp_loc.ops->mknod_h ) { 1067a2: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1067a5: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 1067a8: 85 d2 test %edx,%edx <== NOT EXECUTED 1067aa: 75 19 jne 1067c5 <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 1067ac: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1067af: 85 c0 test %eax,%eax <== NOT EXECUTED 1067b1: 0f 84 7a ff ff ff je 106731 <== NOT EXECUTED 1067b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1067ba: 57 push %edi <== NOT EXECUTED 1067bb: ff d0 call *%eax <== NOT EXECUTED 1067bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1067c0: e9 6c ff ff ff jmp 106731 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 1067c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1067c8: 57 push %edi <== NOT EXECUTED 1067c9: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 1067cc: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 1067cf: 53 push %ebx <== NOT EXECUTED 1067d0: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1067d3: ff d2 call *%edx <== NOT EXECUTED 1067d5: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 1067d7: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1067da: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1067dd: 85 c0 test %eax,%eax <== NOT EXECUTED 1067df: 74 10 je 1067f1 <== NOT EXECUTED 1067e1: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1067e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1067e6: 74 09 je 1067f1 <== NOT EXECUTED 1067e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1067eb: 57 push %edi <== NOT EXECUTED 1067ec: ff d0 call *%eax <== NOT EXECUTED 1067ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1067f1: 89 f0 mov %esi,%eax <== NOT EXECUTED 1067f3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1067f6: 5b pop %ebx <== NOT EXECUTED 1067f7: 5e pop %esi <== NOT EXECUTED 1067f8: 5f pop %edi <== NOT EXECUTED 1067f9: c9 leave <== NOT EXECUTED 1067fa: c3 ret <== NOT EXECUTED 0010d00d : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10d00d: 55 push %ebp <== NOT EXECUTED 10d00e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d010: 57 push %edi <== NOT EXECUTED 10d011: 56 push %esi <== NOT EXECUTED 10d012: 53 push %ebx <== NOT EXECUTED 10d013: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10d016: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10d019: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10d01d: 74 05 je 10d024 <== NOT EXECUTED /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10d01f: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10d022: 76 10 jbe 10d034 <== NOT EXECUTED options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 10d024: e8 87 16 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d029: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d02f: e9 e4 01 00 00 jmp 10d218 <== NOT EXECUTED return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10d034: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d037: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 10d03b: 75 17 jne 10d054 <== NOT EXECUTED errno = ENOTSUP; 10d03d: e8 6e 16 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d042: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d048: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10d04f: e9 94 01 00 00 jmp 10d1e8 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10d054: b8 64 00 00 00 mov $0x64,%eax <== NOT EXECUTED 10d059: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10d05d: 74 0f je 10d06e <== NOT EXECUTED size += strlen( device ) + 1; 10d05f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d061: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 10d064: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10d067: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10d069: f7 d1 not %ecx <== NOT EXECUTED 10d06b: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10d06e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d071: 50 push %eax <== NOT EXECUTED 10d072: e8 ed 95 ff ff call 106664 <== NOT EXECUTED 10d077: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d079: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !temp_mt_entry ) { 10d07c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d07f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d081: 75 10 jne 10d093 <== NOT EXECUTED errno = ENOMEM; 10d083: e8 28 16 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d088: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10d08e: e9 85 01 00 00 jmp 10d218 <== NOT EXECUTED return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10d093: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED temp_mt_entry->options = options; 10d096: 89 70 28 mov %esi,0x28(%eax) <== NOT EXECUTED if ( device ) { 10d099: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10d09d: 74 16 je 10d0b5 <== NOT EXECUTED temp_mt_entry->dev = 10d09f: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10d0a2: 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 ); 10d0a5: 52 push %edx <== NOT EXECUTED 10d0a6: 52 push %edx <== NOT EXECUTED 10d0a7: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10d0aa: 50 push %eax <== NOT EXECUTED 10d0ab: e8 60 27 00 00 call 10f810 <== NOT EXECUTED 10d0b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d0b3: eb 07 jmp 10d0bc <== NOT EXECUTED } else temp_mt_entry->dev = 0; 10d0b5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) <== NOT EXECUTED /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 10d0bc: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 10d0c0: 0f 84 a8 00 00 00 je 10d16e <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( 10d0c6: 6a 01 push $0x1 <== NOT EXECUTED 10d0c8: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10d0cb: 56 push %esi <== NOT EXECUTED 10d0cc: 6a 07 push $0x7 <== NOT EXECUTED 10d0ce: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10d0d1: e8 70 92 ff ff call 106346 <== NOT EXECUTED 10d0d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d0d9: 40 inc %eax <== NOT EXECUTED 10d0da: 0f 84 08 01 00 00 je 10d1e8 <== NOT EXECUTED /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10d0e0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d0e3: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d0e6: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0e8: 75 10 jne 10d0fa <== NOT EXECUTED errno = ENOTSUP; 10d0ea: e8 c1 15 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d0ef: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d0f5: e9 f0 00 00 00 jmp 10d1ea <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10d0fa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d0fd: 56 push %esi <== NOT EXECUTED 10d0fe: ff d0 call *%eax <== NOT EXECUTED 10d100: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d103: 48 dec %eax <== NOT EXECUTED 10d104: 74 10 je 10d116 <== NOT EXECUTED errno = ENOTDIR; 10d106: e8 a5 15 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d10b: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10d111: e9 d4 00 00 00 jmp 10d1ea <== NOT EXECUTED /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10d116: a1 9c cc 11 00 mov 0x11cc9c,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node; if ( the_mount_entry->mt_fs_root.node_access == loc->node_access ) 10d11b: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10d11e: eb 07 jmp 10d127 <== NOT EXECUTED 10d120: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10d123: 74 0e je 10d133 <== 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 ) { 10d125: 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 ); 10d127: 3d a0 cc 11 00 cmp $0x11cca0,%eax <== NOT EXECUTED 10d12c: 75 f2 jne 10d120 <== NOT EXECUTED 10d12e: e9 f0 00 00 00 jmp 10d223 <== NOT EXECUTED /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10d133: e8 78 15 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d138: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10d13e: eb 0b jmp 10d14b <== 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; 10d140: e8 6b 15 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10d145: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d14b: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10d14e: e9 97 00 00 00 jmp 10d1ea <== NOT EXECUTED goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10d153: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d156: 53 push %ebx <== NOT EXECUTED 10d157: ff d0 call *%eax <== NOT EXECUTED 10d159: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d15c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d15e: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10d161: 74 07 je 10d16a <== NOT EXECUTED 10d163: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d165: e9 80 00 00 00 jmp 10d1ea <== NOT EXECUTED 10d16a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d16c: eb 33 jmp 10d1a1 <== NOT EXECUTED * This is a mount of the base file system --> The * mt_point_node.node_access will be set to null to indicate that this * is the root of the entire file system. */ temp_mt_entry->mt_fs_root.node_access = NULL; 10d16e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.handlers = NULL; 10d175: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = NULL; 10d17c: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.node_access = NULL; 10d183: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = NULL; 10d18a: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = NULL; 10d191: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = NULL; 10d198: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED 10d19f: 31 f6 xor %esi,%esi <== NOT EXECUTED } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10d1a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1a4: 53 push %ebx <== NOT EXECUTED 10d1a5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d1a8: ff 52 24 call *0x24(%edx) <== NOT EXECUTED 10d1ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1ae: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1b0: 74 15 je 10d1c7 <== NOT EXECUTED /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10d1b2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d1b5: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10d1b8: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1ba: 74 2e je 10d1ea <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10d1bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1bf: 53 push %ebx <== NOT EXECUTED 10d1c0: ff d0 call *%eax <== NOT EXECUTED 10d1c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1c5: eb 23 jmp 10d1ea <== NOT EXECUTED 10d1c7: 50 push %eax <== NOT EXECUTED 10d1c8: 50 push %eax <== NOT EXECUTED 10d1c9: 53 push %ebx <== NOT EXECUTED 10d1ca: 68 9c cc 11 00 push $0x11cc9c <== NOT EXECUTED 10d1cf: e8 4c c8 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10d1d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1d7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d1d9: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10d1dd: 74 3c je 10d21b <== NOT EXECUTED *mt_entry = temp_mt_entry; 10d1df: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d1e2: 89 1f mov %ebx,(%edi) <== NOT EXECUTED 10d1e4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d1e6: eb 33 jmp 10d21b <== NOT EXECUTED 10d1e8: 31 f6 xor %esi,%esi <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10d1ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1ed: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10d1f0: e8 73 92 ff ff call 106468 <== NOT EXECUTED if ( loc_to_free ) 10d1f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1f8: 85 f6 test %esi,%esi <== NOT EXECUTED 10d1fa: 74 1c je 10d218 <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 10d1fc: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d1ff: 85 c0 test %eax,%eax <== NOT EXECUTED 10d201: 74 15 je 10d218 <== NOT EXECUTED 10d203: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10d206: 85 c0 test %eax,%eax <== NOT EXECUTED 10d208: 74 0e je 10d218 <== NOT EXECUTED 10d20a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d20d: 56 push %esi <== NOT EXECUTED 10d20e: ff d0 call *%eax <== NOT EXECUTED 10d210: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d213: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d216: eb 03 jmp 10d21b <== NOT EXECUTED 10d218: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; } 10d21b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d21e: 5b pop %ebx <== NOT EXECUTED 10d21f: 5e pop %esi <== NOT EXECUTED 10d220: 5f pop %edi <== NOT EXECUTED 10d221: c9 leave <== NOT EXECUTED 10d222: c3 ret <== 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; 10d223: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = loc.handlers; 10d226: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10d229: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = loc.ops; 10d22c: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10d22f: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10d232: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d235: 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 ){ 10d238: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10d23b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d23d: 0f 85 10 ff ff ff jne 10d153 <== NOT EXECUTED 10d243: e9 f8 fe ff ff jmp 10d140 <== NOT EXECUTED 0010687d : */ int newlib_free_buffers( FILE *fp ) { 10687d: 55 push %ebp <== NOT EXECUTED 10687e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106880: 53 push %ebx <== NOT EXECUTED 106881: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 106884: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED switch ( fileno(fp) ) { 106887: 53 push %ebx <== NOT EXECUTED 106888: e8 0f 81 00 00 call 10e99c <== NOT EXECUTED 10688d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106890: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 106893: 77 26 ja 1068bb <== NOT EXECUTED case 0: case 1: case 2: if (fp->_flags & __SMBF) { 106895: 80 7b 0c 00 cmpb $0x0,0xc(%ebx) <== NOT EXECUTED 106899: 79 2c jns 1068c7 <== NOT EXECUTED free( fp->_bf._base ); 10689b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10689e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1068a1: e8 c2 fb ff ff call 106468 <== NOT EXECUTED fp->_flags &= ~__SMBF; 1068a6: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 1068ac: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 1068b2: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 1068b9: eb 09 jmp 1068c4 <== NOT EXECUTED } break; default: fclose(fp); 1068bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1068be: 53 push %ebx <== NOT EXECUTED 1068bf: e8 38 7f 00 00 call 10e7fc <== NOT EXECUTED 1068c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 1068c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 1068c9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1068cc: c9 leave <== NOT EXECUTED 1068cd: c3 ret <== NOT EXECUTED 00106a6f : rtems_device_driver null_close( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a6f: 55 push %ebp <== NOT EXECUTED 106a70: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a72: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a74: c9 leave <== NOT EXECUTED 106a75: c3 ret <== NOT EXECUTED 00106a91 : rtems_device_driver null_control( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a91: 55 push %ebp <== NOT EXECUTED 106a92: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a94: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a96: c9 leave <== NOT EXECUTED 106a97: c3 ret <== NOT EXECUTED 00106a98 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a98: 55 push %ebp <== NOT EXECUTED 106a99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106a9b: 53 push %ebx <== NOT EXECUTED 106a9c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 106a9f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_device_driver status; if ( !initialized ) { 106aa2: 80 3d ac f1 11 00 00 cmpb $0x0,0x11f1ac <== NOT EXECUTED 106aa9: 75 2b jne 106ad6 <== NOT EXECUTED initialized = 1; 106aab: c6 05 ac f1 11 00 01 movb $0x1,0x11f1ac <== NOT EXECUTED status = rtems_io_register_name( 106ab2: 50 push %eax <== NOT EXECUTED 106ab3: 6a 00 push $0x0 <== NOT EXECUTED 106ab5: 53 push %ebx <== NOT EXECUTED 106ab6: 68 51 8e 11 00 push $0x118e51 <== NOT EXECUTED 106abb: e8 f5 00 00 00 call 106bb5 <== NOT EXECUTED "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 106ac0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ac3: 85 c0 test %eax,%eax <== NOT EXECUTED 106ac5: 74 09 je 106ad0 <== NOT EXECUTED rtems_fatal_error_occurred(status); 106ac7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106aca: 50 push %eax <== NOT EXECUTED 106acb: e8 18 38 00 00 call 10a2e8 <== NOT EXECUTED NULL_major = major; 106ad0: 89 1d c0 f3 11 00 mov %ebx,0x11f3c0 <== NOT EXECUTED } return RTEMS_SUCCESSFUL; } 106ad6: 31 c0 xor %eax,%eax <== NOT EXECUTED 106ad8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106adb: c9 leave <== NOT EXECUTED 106adc: c3 ret <== NOT EXECUTED 00106a68 : rtems_device_driver null_open( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a68: 55 push %ebp <== NOT EXECUTED 106a69: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a6b: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a6d: c9 leave <== NOT EXECUTED 106a6e: c3 ret <== NOT EXECUTED 00106a76 : rtems_device_driver null_read( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a76: 55 push %ebp <== NOT EXECUTED 106a77: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a79: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a7b: c9 leave <== NOT EXECUTED 106a7c: c3 ret <== NOT EXECUTED 00106a7d : rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a7d: 55 push %ebp <== NOT EXECUTED 106a7e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106a80: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 106a83: 85 d2 test %edx,%edx <== NOT EXECUTED 106a85: 74 06 je 106a8d <== NOT EXECUTED rw_args->bytes_moved = rw_args->count; 106a87: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 106a8a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a8d: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a8f: c9 leave <== NOT EXECUTED 106a90: c3 ret <== NOT EXECUTED 00106b84 : int open( const char *pathname, int flags, ... ) { 106b84: 55 push %ebp <== NOT EXECUTED 106b85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106b87: 57 push %edi <== NOT EXECUTED 106b88: 56 push %esi <== NOT EXECUTED 106b89: 53 push %ebx <== NOT EXECUTED 106b8a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 106b8d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106b90: 40 inc %eax <== NOT EXECUTED if ( ( status & _FREAD ) == _FREAD ) 106b91: 89 c3 mov %eax,%ebx <== NOT EXECUTED 106b93: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 106b96: f7 db neg %ebx <== NOT EXECUTED 106b98: 83 e3 04 and $0x4,%ebx <== NOT EXECUTED eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 106b9b: a8 02 test $0x2,%al <== NOT EXECUTED 106b9d: 74 03 je 106ba2 <== NOT EXECUTED eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 106b9f: 83 cb 02 or $0x2,%ebx <== NOT EXECUTED va_start(ap, flags); mode = va_arg( ap, int ); 106ba2: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 106ba5: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED * code does not require changes here since network file * descriptors are obtained using socket(), not open(). */ /* allocate a file control block */ iop = rtems_libio_allocate(); 106ba8: e8 58 63 00 00 call 10cf05 <== NOT EXECUTED 106bad: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( iop == 0 ) { 106bb0: be 17 00 00 00 mov $0x17,%esi <== NOT EXECUTED 106bb5: 85 c0 test %eax,%eax <== NOT EXECUTED 106bb7: 0f 84 8e 01 00 00 je 106d4b <== NOT EXECUTED /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 106bbd: 6a 01 push $0x1 <== NOT EXECUTED 106bbf: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 106bc2: 57 push %edi <== NOT EXECUTED 106bc3: 53 push %ebx <== NOT EXECUTED 106bc4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106bc7: e8 7a f7 ff ff call 106346 <== NOT EXECUTED pathname, eval_flags, &loc, true ); if ( status == -1 ) { 106bcc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106bcf: 40 inc %eax <== NOT EXECUTED 106bd0: 75 61 jne 106c33 <== NOT EXECUTED if ( errno != ENOENT ) { 106bd2: e8 d9 7a 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106bd7: 83 38 02 cmpl $0x2,(%eax) <== NOT EXECUTED 106bda: 75 2c jne 106c08 <== 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) ) { 106bdc: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED 106be1: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 106be8: 0f 84 2c 01 00 00 je 106d1a <== NOT EXECUTED rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 106bee: 6a 00 push $0x0 <== NOT EXECUTED 106bf0: 6a 00 push $0x0 <== NOT EXECUTED 106bf2: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 106bf5: 80 cc 80 or $0x80,%ah <== NOT EXECUTED 106bf8: 50 push %eax <== NOT EXECUTED 106bf9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106bfc: e8 fb fa ff ff call 1066fc <== NOT EXECUTED if ( rc ) { 106c01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106c04: 85 c0 test %eax,%eax <== NOT EXECUTED 106c06: 74 0c je 106c14 <== NOT EXECUTED rc = errno; 106c08: e8 a3 7a 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106c0d: 8b 30 mov (%eax),%esi <== NOT EXECUTED 106c0f: e9 02 01 00 00 jmp 106d16 <== NOT EXECUTED goto done; } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true ); 106c14: 6a 01 push $0x1 <== NOT EXECUTED 106c16: 57 push %edi <== NOT EXECUTED 106c17: 6a 00 push $0x0 <== NOT EXECUTED 106c19: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106c1c: e8 25 f7 ff ff call 106346 <== NOT EXECUTED if ( status != 0 ) { /* The file did not exist */ 106c21: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106c24: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED 106c29: 85 c0 test %eax,%eax <== NOT EXECUTED 106c2b: 0f 85 e9 00 00 00 jne 106d1a <== NOT EXECUTED 106c31: eb 1b jmp 106c4e <== NOT EXECUTED rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 106c33: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106c36: 25 00 0a 00 00 and $0xa00,%eax <== NOT EXECUTED 106c3b: 3d 00 0a 00 00 cmp $0xa00,%eax <== NOT EXECUTED 106c40: 75 0c jne 106c4e <== NOT EXECUTED 106c42: be 11 00 00 00 mov $0x11,%esi <== NOT EXECUTED 106c47: 89 fb mov %edi,%ebx <== NOT EXECUTED 106c49: e9 ce 00 00 00 jmp 106d1c <== NOT EXECUTED /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 106c4e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 106c51: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106c54: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED iop->file_info = loc.node_access; 106c57: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 106c5a: 89 42 2c mov %eax,0x2c(%edx) <== NOT EXECUTED iop->flags |= rtems_libio_fcntl_flags( flags ); 106c5d: 8b 5a 0c mov 0xc(%edx),%ebx <== NOT EXECUTED 106c60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106c63: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106c66: e8 2c 63 00 00 call 10cf97 <== NOT EXECUTED 106c6b: 09 c3 or %eax,%ebx <== NOT EXECUTED 106c6d: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 106c70: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED iop->pathinfo = loc; 106c73: 89 c7 mov %eax,%edi <== NOT EXECUTED 106c75: 83 c7 10 add $0x10,%edi <== NOT EXECUTED 106c78: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 106c7b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106c80: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !iop->handlers->open_h ) { 106c82: 89 c2 mov %eax,%edx <== NOT EXECUTED 106c84: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 106c87: 8b 00 mov (%eax),%eax <== NOT EXECUTED 106c89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106c8c: 85 c0 test %eax,%eax <== NOT EXECUTED 106c8e: 0f 84 df 00 00 00 je 106d73 <== NOT EXECUTED rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 106c94: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 106c97: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106c9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106c9d: 52 push %edx <== NOT EXECUTED 106c9e: ff d0 call *%eax <== NOT EXECUTED 106ca0: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( rc ) 106ca2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ca5: 85 c0 test %eax,%eax <== NOT EXECUTED 106ca7: 0f 85 cb 00 00 00 jne 106d78 <== NOT EXECUTED /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 106cad: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 106cb4: 0f 84 9d 00 00 00 je 106d57 <== NOT EXECUTED rc = ftruncate( iop - rtems_libio_iops, 0 ); 106cba: 50 push %eax <== NOT EXECUTED 106cbb: 50 push %eax <== NOT EXECUTED 106cbc: 6a 00 push $0x0 <== NOT EXECUTED 106cbe: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 106cc1: 2b 05 a0 c8 11 00 sub 0x11c8a0,%eax <== NOT EXECUTED 106cc7: c1 f8 02 sar $0x2,%eax <== NOT EXECUTED 106cca: 69 c0 c5 4e ec c4 imul $0xc4ec4ec5,%eax,%eax <== NOT EXECUTED 106cd0: 50 push %eax <== NOT EXECUTED 106cd1: e8 ce 5f 00 00 call 10cca4 <== NOT EXECUTED 106cd6: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( rc ) { 106cd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106cdb: 85 c0 test %eax,%eax <== NOT EXECUTED 106cdd: 74 78 je 106d57 <== NOT EXECUTED if(errno) rc = errno; 106cdf: e8 cc 79 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106ce4: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 106ce7: 74 07 je 106cf0 <== NOT EXECUTED 106ce9: e8 c2 79 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106cee: 8b 30 mov (%eax),%esi <== NOT EXECUTED close( iop - rtems_libio_iops ); 106cf0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106cf3: a1 a0 c8 11 00 mov 0x11c8a0,%eax <== NOT EXECUTED 106cf8: 29 45 e0 sub %eax,-0x20(%ebp) <== NOT EXECUTED 106cfb: c1 7d e0 02 sarl $0x2,-0x20(%ebp) <== NOT EXECUTED 106cff: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax <== NOT EXECUTED 106d06: 50 push %eax <== NOT EXECUTED 106d07: e8 14 5f 00 00 call 10cc20 <== NOT EXECUTED 106d0c: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 106d13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 106d16: 85 f6 test %esi,%esi <== NOT EXECUTED 106d18: 74 3d je 106d57 <== NOT EXECUTED 106d1a: 31 db xor %ebx,%ebx <== NOT EXECUTED if ( iop ) 106d1c: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 106d20: 74 0e je 106d30 <== NOT EXECUTED rtems_libio_free( iop ); 106d22: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d25: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 106d28: e8 83 61 00 00 call 10ceb0 <== NOT EXECUTED 106d2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) 106d30: 85 db test %ebx,%ebx <== NOT EXECUTED 106d32: 74 17 je 106d4b <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 106d34: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 106d37: 85 c0 test %eax,%eax <== NOT EXECUTED 106d39: 74 10 je 106d4b <== NOT EXECUTED 106d3b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106d3e: 85 c0 test %eax,%eax <== NOT EXECUTED 106d40: 74 09 je 106d4b <== NOT EXECUTED 106d42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d45: 53 push %ebx <== NOT EXECUTED 106d46: ff d0 call *%eax <== NOT EXECUTED 106d48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( rc ); 106d4b: e8 60 79 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106d50: 89 30 mov %esi,(%eax) <== NOT EXECUTED 106d52: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106d55: eb 14 jmp 106d6b <== NOT EXECUTED } return iop - rtems_libio_iops; 106d57: 8b 15 a0 c8 11 00 mov 0x11c8a0,%edx <== NOT EXECUTED 106d5d: 29 55 e0 sub %edx,-0x20(%ebp) <== NOT EXECUTED 106d60: c1 7d e0 02 sarl $0x2,-0x20(%ebp) <== NOT EXECUTED 106d64: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax <== NOT EXECUTED } 106d6b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106d6e: 5b pop %ebx <== NOT EXECUTED 106d6f: 5e pop %esi <== NOT EXECUTED 106d70: 5f pop %edi <== NOT EXECUTED 106d71: c9 leave <== NOT EXECUTED 106d72: c3 ret <== 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; 106d73: be 86 00 00 00 mov $0x86,%esi <== NOT EXECUTED 106d78: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 106d7b: eb 9f jmp 106d1c <== NOT EXECUTED 00106b24 : /* * This is a replaceable stub */ void open_dev_console(void) { 106b24: 55 push %ebp <== NOT EXECUTED 106b25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106b27: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { 106b2a: 6a 00 push $0x0 <== NOT EXECUTED 106b2c: 6a 00 push $0x0 <== NOT EXECUTED 106b2e: 68 13 56 11 00 push $0x115613 <== NOT EXECUTED 106b33: e8 4c 00 00 00 call 106b84 <== NOT EXECUTED 106b38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106b3b: 40 inc %eax <== NOT EXECUTED 106b3c: 74 41 je 106b7f <== 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) 106b3e: 52 push %edx <== NOT EXECUTED 106b3f: 6a 00 push $0x0 <== NOT EXECUTED 106b41: 6a 01 push $0x1 <== NOT EXECUTED 106b43: 68 13 56 11 00 push $0x115613 <== NOT EXECUTED 106b48: e8 37 00 00 00 call 106b84 <== NOT EXECUTED 106b4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106b50: 40 inc %eax <== NOT EXECUTED 106b51: 75 0a jne 106b5d <== NOT EXECUTED rtems_fatal_error_occurred( error_code | '1' ); 106b53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106b56: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED 106b5b: eb 1d jmp 106b7a <== NOT EXECUTED if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 106b5d: 50 push %eax <== NOT EXECUTED 106b5e: 6a 00 push $0x0 <== NOT EXECUTED 106b60: 6a 01 push $0x1 <== NOT EXECUTED 106b62: 68 13 56 11 00 push $0x115613 <== NOT EXECUTED 106b67: e8 18 00 00 00 call 106b84 <== NOT EXECUTED 106b6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106b6f: 40 inc %eax <== NOT EXECUTED 106b70: 75 0d jne 106b7f <== NOT EXECUTED rtems_fatal_error_occurred( error_code | '2' ); 106b72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106b75: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED 106b7a: e8 e1 2b 00 00 call 109760 <== NOT EXECUTED } 106b7f: c9 leave <== NOT EXECUTED 106b80: c3 ret <== NOT EXECUTED 0012029c : * open a directory. */ DIR * opendir( const char *name ) { 12029c: 55 push %ebp <== NOT EXECUTED 12029d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12029f: 56 push %esi <== NOT EXECUTED 1202a0: 53 push %ebx <== NOT EXECUTED register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 1202a1: 52 push %edx <== NOT EXECUTED 1202a2: 52 push %edx <== NOT EXECUTED 1202a3: 6a 00 push $0x0 <== NOT EXECUTED 1202a5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1202a8: e8 6f aa fe ff call 10ad1c <== NOT EXECUTED 1202ad: 89 c6 mov %eax,%esi <== NOT EXECUTED 1202af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1202b2: 31 db xor %ebx,%ebx <== NOT EXECUTED 1202b4: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 1202b7: 74 62 je 12031b <== NOT EXECUTED return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 1202b9: 50 push %eax <== NOT EXECUTED 1202ba: 6a 01 push $0x1 <== NOT EXECUTED 1202bc: 6a 02 push $0x2 <== NOT EXECUTED 1202be: 56 push %esi <== NOT EXECUTED 1202bf: e8 f8 8f 00 00 call 1292bc <== NOT EXECUTED 1202c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1202c7: 40 inc %eax <== NOT EXECUTED 1202c8: 74 31 je 1202fb <== NOT EXECUTED 1202ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1202cd: 6a 18 push $0x18 <== NOT EXECUTED 1202cf: e8 08 a2 fe ff call 10a4dc <== NOT EXECUTED 1202d4: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1202d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1202d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1202db: 74 1e je 1202fb <== NOT EXECUTED * If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE * buffer that it cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdirentries() */ dirp->dd_buf = malloc (512); 1202dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1202e0: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 1202e5: e8 f2 a1 fe ff call 10a4dc <== NOT EXECUTED 1202ea: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED dirp->dd_len = 512; 1202ed: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx) <== NOT EXECUTED if (dirp->dd_buf == NULL) { 1202f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1202f7: 85 c0 test %eax,%eax <== NOT EXECUTED 1202f9: 75 10 jne 12030b <== NOT EXECUTED close (fd); 1202fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1202fe: 56 push %esi <== NOT EXECUTED 1202ff: e8 fc 9a fe ff call 109e00 <== NOT EXECUTED 120304: 31 db xor %ebx,%ebx <== NOT EXECUTED 120306: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120309: eb 10 jmp 12031b <== NOT EXECUTED return NULL; } dirp->dd_fd = fd; 12030b: 89 33 mov %esi,(%ebx) <== NOT EXECUTED dirp->dd_loc = 0; 12030d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED dirp->dd_seek = 0; 120314: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED /* * Set up seek point for rewinddir. */ return dirp; } 12031b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12031d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120320: 5b pop %ebx <== NOT EXECUTED 120321: 5e pop %esi <== NOT EXECUTED 120322: c9 leave <== NOT EXECUTED 120323: c3 ret <== NOT EXECUTED 0010777c : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 10777c: 55 push %ebp <== NOT EXECUTED 10777d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10777f: 56 push %esi <== NOT EXECUTED 107780: 53 push %ebx <== NOT EXECUTED 107781: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 107784: 89 d3 mov %edx,%ebx <== NOT EXECUTED 107786: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { 107789: 8b 4a 34 mov 0x34(%edx),%ecx <== NOT EXECUTED 10778c: f6 c1 01 test $0x1,%cl <== NOT EXECUTED 10778f: 0f 84 df 00 00 00 je 107874 <== NOT EXECUTED switch (c) { 107795: 3c 09 cmp $0x9,%al <== NOT EXECUTED 107797: 74 76 je 10780f <== NOT EXECUTED 107799: 77 0d ja 1077a8 <== NOT EXECUTED 10779b: 3c 08 cmp $0x8,%al <== NOT EXECUTED 10779d: 0f 85 a6 00 00 00 jne 107849 <== NOT EXECUTED 1077a3: e9 94 00 00 00 jmp 10783c <== NOT EXECUTED 1077a8: 3c 0a cmp $0xa,%al <== NOT EXECUTED 1077aa: 74 0a je 1077b6 <== NOT EXECUTED 1077ac: 3c 0d cmp $0xd,%al <== NOT EXECUTED 1077ae: 0f 85 95 00 00 00 jne 107849 <== NOT EXECUTED 1077b4: eb 33 jmp 1077e9 <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 1077b6: 80 e1 20 and $0x20,%cl <== NOT EXECUTED 1077b9: 74 07 je 1077c2 <== NOT EXECUTED tty->column = 0; 1077bb: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 1077c2: f6 43 34 04 testb $0x4,0x34(%ebx) <== NOT EXECUTED 1077c6: 0f 84 a8 00 00 00 je 107874 <== NOT EXECUTED rtems_termios_puts ("\r", 1, tty); 1077cc: 50 push %eax <== NOT EXECUTED 1077cd: 53 push %ebx <== NOT EXECUTED 1077ce: 6a 01 push $0x1 <== NOT EXECUTED 1077d0: 68 93 67 11 00 push $0x116793 <== NOT EXECUTED 1077d5: e8 8d fe ff ff call 107667 <== NOT EXECUTED tty->column = 0; 1077da: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 1077e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1077e4: e9 8b 00 00 00 jmp 107874 <== NOT EXECUTED } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 1077e9: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 1077ec: 74 0a je 1077f8 <== NOT EXECUTED 1077ee: 83 7a 28 00 cmpl $0x0,0x28(%edx) <== NOT EXECUTED 1077f2: 0f 84 8c 00 00 00 je 107884 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 1077f8: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 1077fb: 74 09 je 107806 <== NOT EXECUTED c = '\n'; 1077fd: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 107801: 80 e1 20 and $0x20,%cl <== NOT EXECUTED 107804: 74 6e je 107874 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 107806: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 10780d: eb 65 jmp 107874 <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); 10780f: 8b 52 28 mov 0x28(%edx),%edx <== NOT EXECUTED 107812: 89 d0 mov %edx,%eax <== NOT EXECUTED 107814: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 107817: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED 10781c: 29 c6 sub %eax,%esi <== NOT EXECUTED if ((tty->termios.c_oflag & TABDLY) == XTABS) { 10781e: 81 e1 00 18 00 00 and $0x1800,%ecx <== NOT EXECUTED 107824: 81 f9 00 18 00 00 cmp $0x1800,%ecx <== NOT EXECUTED 10782a: 8d 04 16 lea (%esi,%edx,1),%eax <== NOT EXECUTED 10782d: 75 15 jne 107844 <== NOT EXECUTED tty->column += i; 10782f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_termios_puts ( " ", i, tty); 107832: 50 push %eax <== NOT EXECUTED 107833: 53 push %ebx <== NOT EXECUTED 107834: 56 push %esi <== NOT EXECUTED 107835: 68 95 67 11 00 push $0x116795 <== NOT EXECUTED 10783a: eb 40 jmp 10787c <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 10783c: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10783f: 85 c0 test %eax,%eax <== NOT EXECUTED 107841: 7e 31 jle 107874 <== NOT EXECUTED tty->column--; 107843: 48 dec %eax <== NOT EXECUTED 107844: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 107847: eb 2b jmp 107874 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 107849: 80 e1 02 and $0x2,%cl <== NOT EXECUTED 10784c: 74 14 je 107862 <== NOT EXECUTED c = toupper(c); 10784e: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 107851: a1 b8 a9 11 00 mov 0x11a9b8,%eax <== NOT EXECUTED 107856: f6 04 10 02 testb $0x2,(%eax,%edx,1) <== NOT EXECUTED 10785a: 74 03 je 10785f <== NOT EXECUTED 10785c: 83 ea 20 sub $0x20,%edx <== NOT EXECUTED 10785f: 88 55 f4 mov %dl,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 107862: 0f b6 55 f4 movzbl -0xc(%ebp),%edx <== NOT EXECUTED 107866: a1 b8 a9 11 00 mov 0x11a9b8,%eax <== NOT EXECUTED 10786b: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED 10786f: 75 03 jne 107874 <== NOT EXECUTED tty->column++; 107871: ff 43 28 incl 0x28(%ebx) <== NOT EXECUTED break; } } rtems_termios_puts (&c, 1, tty); 107874: 56 push %esi <== NOT EXECUTED 107875: 53 push %ebx <== NOT EXECUTED 107876: 6a 01 push $0x1 <== NOT EXECUTED 107878: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10787b: 50 push %eax <== NOT EXECUTED 10787c: e8 e6 fd ff ff call 107667 <== NOT EXECUTED 107881: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107884: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107887: 5b pop %ebx <== NOT EXECUTED 107888: 5e pop %esi <== NOT EXECUTED 107889: c9 leave <== NOT EXECUTED 10788a: c3 ret <== NOT EXECUTED 001081d8 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 1081d8: 55 push %ebp <== NOT EXECUTED 1081d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1081db: 53 push %ebx <== NOT EXECUTED 1081dc: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1081df: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1081e2: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED /* * Update call statistics */ MSBUMP(memalign_calls, 1); 1081e5: ff 05 44 08 12 00 incl 0x120844 <== NOT EXECUTED if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 1081eb: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 1081ee: 85 d0 test %edx,%eax <== NOT EXECUTED 1081f0: 75 05 jne 1081f7 <== NOT EXECUTED 1081f2: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 1081f5: 77 08 ja 1081ff <== NOT EXECUTED /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 1081f7: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 1081fc: 5b pop %ebx <== NOT EXECUTED 1081fd: c9 leave <== NOT EXECUTED 1081fe: c3 ret <== NOT EXECUTED /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 1081ff: 89 4d 10 mov %ecx,0x10(%ebp) <== NOT EXECUTED 108202: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 108205: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 108208: 5b pop %ebx <== NOT EXECUTED 108209: c9 leave <== NOT EXECUTED /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10820a: e9 c1 03 00 00 jmp 1085d0 <== NOT EXECUTED 00107032 : * printk * * Kernel printf function requiring minimal infrastrure. */ void printk(const char *fmt, ...) { 107032: 55 push %ebp <== NOT EXECUTED 107033: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107035: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 107038: 8d 45 0c lea 0xc(%ebp),%eax <== NOT EXECUTED va_list ap; /* points to each unnamed argument in turn */ va_start(ap, fmt); /* make ap point to 1st unnamed arg */ vprintk(fmt, ap); 10703b: 50 push %eax <== NOT EXECUTED 10703c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10703f: e8 54 fd ff ff call 106d98 <== NOT EXECUTED 107044: 83 c4 10 add $0x10,%esp <== NOT EXECUTED va_end(ap); /* clean up when done */ } 107047: c9 leave <== NOT EXECUTED 107048: c3 ret <== NOT EXECUTED 00107e4c : int printk_plugin( void *ignored, const char *format, ... ) { 107e4c: 55 push %ebp <== NOT EXECUTED 107e4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107e4f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 107e52: 8d 45 10 lea 0x10(%ebp),%eax <== NOT EXECUTED va_list arg_pointer; va_start (arg_pointer, format); vprintk( format, arg_pointer ); 107e55: 50 push %eax <== NOT EXECUTED 107e56: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 107e59: e8 3a fd ff ff call 107b98 <== NOT EXECUTED va_end(arg_pointer); /* clean up when done */ return 0; } 107e5e: 31 c0 xor %eax,%eax <== NOT EXECUTED 107e60: c9 leave <== NOT EXECUTED 107e61: c3 ret <== NOT EXECUTED 00114cec : ssize_t read( int fd, void *buffer, size_t count ) { 114cec: 55 push %ebp <== NOT EXECUTED 114ced: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114cef: 56 push %esi <== NOT EXECUTED 114cf0: 53 push %ebx <== NOT EXECUTED 114cf1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114cf4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 114cf7: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 114cfa: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 114d00: 73 11 jae 114d13 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 114d02: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 114d05: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 114d0b: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 114d0e: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 114d11: 75 0d jne 114d20 <== NOT EXECUTED 114d13: e8 98 99 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114d18: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 114d1e: eb 31 jmp 114d51 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 114d20: 85 f6 test %esi,%esi <== NOT EXECUTED 114d22: 74 0b je 114d2f <== NOT EXECUTED rtems_libio_check_count( count ); 114d24: 31 c0 xor %eax,%eax <== NOT EXECUTED 114d26: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114d28: 74 3c je 114d66 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 114d2a: 80 e2 02 and $0x2,%dl <== NOT EXECUTED 114d2d: 75 0d jne 114d3c <== NOT EXECUTED 114d2f: e8 7c 99 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114d34: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 114d3a: eb 15 jmp 114d51 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 114d3c: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 114d3f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 114d42: 85 c0 test %eax,%eax <== NOT EXECUTED 114d44: 75 10 jne 114d56 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 114d46: e8 65 99 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114d4b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 114d51: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114d54: eb 10 jmp 114d66 <== NOT EXECUTED rc = (*iop->handlers->read_h)( iop, buffer, count ); 114d56: 52 push %edx <== NOT EXECUTED 114d57: 51 push %ecx <== NOT EXECUTED 114d58: 56 push %esi <== NOT EXECUTED 114d59: 53 push %ebx <== NOT EXECUTED 114d5a: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 114d5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d5f: 85 c0 test %eax,%eax <== NOT EXECUTED 114d61: 7e 03 jle 114d66 <== NOT EXECUTED iop->offset += rc; 114d63: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 114d66: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114d69: 5b pop %ebx <== NOT EXECUTED 114d6a: 5e pop %esi <== NOT EXECUTED 114d6b: c9 leave <== NOT EXECUTED 114d6c: c3 ret <== NOT EXECUTED 0012051c : /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) { 12051c: 55 push %ebp <== NOT EXECUTED 12051d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12051f: 56 push %esi <== NOT EXECUTED 120520: 53 push %ebx <== NOT EXECUTED 120521: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED register struct dirent *dp; if ( !dirp ) 120524: 85 db test %ebx,%ebx <== NOT EXECUTED 120526: 74 5b je 120583 <== NOT EXECUTED return NULL; for (;;) { if (dirp->dd_loc == 0) { 120528: 83 7b 04 00 cmpl $0x0,0x4(%ebx) <== NOT EXECUTED 12052c: 75 18 jne 120546 <== NOT EXECUTED dirp->dd_size = getdents (dirp->dd_fd, 12052e: 50 push %eax <== NOT EXECUTED 12052f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 120532: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 120535: ff 33 pushl (%ebx) <== NOT EXECUTED 120537: e8 e4 8e 00 00 call 129420 <== NOT EXECUTED 12053c: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 12053f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120542: 85 c0 test %eax,%eax <== NOT EXECUTED 120544: 7e 3d jle 120583 <== NOT EXECUTED return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 120546: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 120549: 3b 4b 08 cmp 0x8(%ebx),%ecx <== NOT EXECUTED 12054c: 7c 09 jl 120557 <== NOT EXECUTED dirp->dd_loc = 0; 12054e: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED 120555: eb d1 jmp 120528 <== NOT EXECUTED continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 120557: 89 ca mov %ecx,%edx <== NOT EXECUTED 120559: 03 53 0c add 0xc(%ebx),%edx <== NOT EXECUTED if ((intptr_t)dp & 03) /* bogus pointer check */ 12055c: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 12055f: 75 22 jne 120583 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 120561: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 120564: 66 85 c0 test %ax,%ax <== NOT EXECUTED 120567: 74 1a je 120583 <== NOT EXECUTED 120569: 0f b7 f0 movzwl %ax,%esi <== NOT EXECUTED 12056c: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 12056f: 40 inc %eax <== NOT EXECUTED 120570: 29 c8 sub %ecx,%eax <== NOT EXECUTED 120572: 39 c6 cmp %eax,%esi <== NOT EXECUTED 120574: 7f 0d jg 120583 <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 120576: 8d 04 0e lea (%esi,%ecx,1),%eax <== NOT EXECUTED 120579: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (dp->d_ino == 0) 12057c: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 12057f: 74 a7 je 120528 <== NOT EXECUTED 120581: eb 02 jmp 120585 <== NOT EXECUTED 120583: 31 d2 xor %edx,%edx <== NOT EXECUTED continue; return (dp); } } 120585: 89 d0 mov %edx,%eax <== NOT EXECUTED 120587: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12058a: 5b pop %ebx <== NOT EXECUTED 12058b: 5e pop %esi <== NOT EXECUTED 12058c: c9 leave <== NOT EXECUTED 12058d: c3 ret <== NOT EXECUTED 00120590 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 120590: 55 push %ebp <== NOT EXECUTED 120591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120593: 57 push %edi <== NOT EXECUTED 120594: 56 push %esi <== NOT EXECUTED 120595: 53 push %ebx <== NOT EXECUTED 120596: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 120599: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if (!buf) 12059c: 85 ff test %edi,%edi <== NOT EXECUTED 12059e: 75 0d jne 1205ad <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 1205a0: e8 fb a4 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1205a5: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 1205ab: eb 43 jmp 1205f0 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 1205ad: 6a 00 push $0x0 <== NOT EXECUTED 1205af: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 1205b2: 56 push %esi <== NOT EXECUTED 1205b3: 6a 00 push $0x0 <== NOT EXECUTED 1205b5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1205b8: e8 3d 99 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 1205bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1205c0: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1205c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1205c5: 0f 85 87 00 00 00 jne 120652 <== NOT EXECUTED return -1; if ( !loc.ops->node_type_h ){ 1205cb: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1205ce: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1205d1: 85 d2 test %edx,%edx <== NOT EXECUTED 1205d3: 75 20 jne 1205f5 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1205d5: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1205d8: 85 c0 test %eax,%eax <== NOT EXECUTED 1205da: 74 09 je 1205e5 <== NOT EXECUTED 1205dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1205df: 56 push %esi <== NOT EXECUTED 1205e0: ff d0 call *%eax <== NOT EXECUTED 1205e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1205e5: e8 b6 a4 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1205ea: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1205f0: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1205f3: eb 5d jmp 120652 <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 1205f5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1205f8: 56 push %esi <== NOT EXECUTED 1205f9: ff d2 call *%edx <== NOT EXECUTED 1205fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1205fe: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 120601: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120604: 74 21 je 120627 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120606: 85 c0 test %eax,%eax <== NOT EXECUTED 120608: 74 10 je 12061a <== NOT EXECUTED 12060a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12060d: 85 c0 test %eax,%eax <== NOT EXECUTED 12060f: 74 09 je 12061a <== NOT EXECUTED 120611: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120614: 56 push %esi <== NOT EXECUTED 120615: ff d0 call *%eax <== NOT EXECUTED 120617: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 12061a: e8 81 a4 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 12061f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 120625: eb c9 jmp 1205f0 <== NOT EXECUTED } if ( !loc.ops->readlink_h ){ 120627: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 12062a: 85 d2 test %edx,%edx <== NOT EXECUTED 12062c: 74 a7 je 1205d5 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 12062e: 50 push %eax <== NOT EXECUTED 12062f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 120632: 57 push %edi <== NOT EXECUTED 120633: 56 push %esi <== NOT EXECUTED 120634: ff d2 call *%edx <== NOT EXECUTED 120636: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120638: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12063b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12063e: 85 c0 test %eax,%eax <== NOT EXECUTED 120640: 74 10 je 120652 <== NOT EXECUTED 120642: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120645: 85 c0 test %eax,%eax <== NOT EXECUTED 120647: 74 09 je 120652 <== NOT EXECUTED 120649: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12064c: 56 push %esi <== NOT EXECUTED 12064d: ff d0 call *%eax <== NOT EXECUTED 12064f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120652: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120654: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120657: 5b pop %ebx <== NOT EXECUTED 120658: 5e pop %esi <== NOT EXECUTED 120659: 5f pop %edi <== NOT EXECUTED 12065a: c9 leave <== NOT EXECUTED 12065b: c3 ret <== NOT EXECUTED 00114dec : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 114dec: 55 push %ebp <== NOT EXECUTED 114ded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114def: 57 push %edi <== NOT EXECUTED 114df0: 56 push %esi <== NOT EXECUTED 114df1: 53 push %ebx <== NOT EXECUTED 114df2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 114df5: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 114df8: ff 05 20 c9 11 00 incl 0x11c920 <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 114dfe: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 114e05: 75 1a jne 114e21 <== NOT EXECUTED if (_Thread_Dispatch_disable_level > 0) 114e07: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 114e0c: 85 c0 test %eax,%eax <== NOT EXECUTED 114e0e: 0f 85 b7 00 00 00 jne 114ecb <== NOT EXECUTED return (void *) 0; if (_ISR_Nest_level > 0) 114e14: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 114e19: 85 c0 test %eax,%eax <== NOT EXECUTED 114e1b: 0f 85 aa 00 00 00 jne 114ecb <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 114e21: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 114e25: 75 0e jne 114e35 <== NOT EXECUTED return malloc( size ); 114e27: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114e2a: 53 push %ebx <== NOT EXECUTED 114e2b: e8 34 18 ff ff call 106664 <== NOT EXECUTED 114e30: e9 8e 00 00 00 jmp 114ec3 <== NOT EXECUTED if ( !size ) { 114e35: 85 db test %ebx,%ebx <== NOT EXECUTED 114e37: 75 14 jne 114e4d <== NOT EXECUTED free( ptr ); 114e39: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114e3c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114e3f: e8 24 16 ff ff call 106468 <== NOT EXECUTED 114e44: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 114e4b: eb 79 jmp 114ec6 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 114e4d: 52 push %edx <== NOT EXECUTED 114e4e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 114e51: 50 push %eax <== NOT EXECUTED 114e52: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114e55: 68 b8 c8 11 00 push $0x11c8b8 <== NOT EXECUTED 114e5a: e8 05 01 00 00 call 114f64 <_Protected_heap_Get_block_size> <== NOT EXECUTED 114e5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114e62: 84 c0 test %al,%al <== NOT EXECUTED 114e64: 75 0d jne 114e73 <== NOT EXECUTED errno = EINVAL; 114e66: e8 45 98 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114e6b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 114e71: eb 58 jmp 114ecb <== NOT EXECUTED #if defined(RTEMS_MALLOC_BOUNDARY_HELPERS) if (rtems_malloc_boundary_helpers) resize += (*rtems_malloc_boundary_helpers->overhead)(); #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) { 114e73: 50 push %eax <== NOT EXECUTED 114e74: 53 push %ebx <== NOT EXECUTED 114e75: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114e78: 68 b8 c8 11 00 push $0x11c8b8 <== NOT EXECUTED 114e7d: e8 1a 01 00 00 call 114f9c <_Protected_heap_Resize_block> <== NOT EXECUTED 114e82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114e85: 84 c0 test %al,%al <== NOT EXECUTED 114e87: 75 49 jne 114ed2 <== 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 ); 114e89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114e8c: 53 push %ebx <== NOT EXECUTED 114e8d: e8 d2 17 ff ff call 106664 <== NOT EXECUTED 114e92: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 114e95: ff 0d 14 c9 11 00 decl 0x11c914 <== NOT EXECUTED if ( !new_area ) { 114e9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114e9e: 85 c0 test %eax,%eax <== NOT EXECUTED 114ea0: 74 29 je 114ecb <== NOT EXECUTED return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 114ea2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 114ea5: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 114ea7: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 114ea9: 76 02 jbe 114ead <== NOT EXECUTED 114eab: 89 c1 mov %eax,%ecx <== NOT EXECUTED 114ead: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 114eb0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 114eb3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED free( ptr ); 114eb5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114eb8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114ebb: e8 a8 15 ff ff call 106468 <== NOT EXECUTED 114ec0: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 114ec3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 114ec6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114ec9: eb 07 jmp 114ed2 <== NOT EXECUTED return new_area; 114ecb: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED } 114ed2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ed5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114ed8: 5b pop %ebx <== NOT EXECUTED 114ed9: 5e pop %esi <== NOT EXECUTED 114eda: 5f pop %edi <== NOT EXECUTED 114edb: c9 leave <== NOT EXECUTED 114edc: c3 ret <== NOT EXECUTED 0012065c : #include int rmdir( const char *pathname ) { 12065c: 55 push %ebp <== NOT EXECUTED 12065d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12065f: 56 push %esi <== NOT EXECUTED 120660: 53 push %ebx <== NOT EXECUTED 120661: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 120664: 6a 00 push $0x0 <== NOT EXECUTED 120666: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 120669: 56 push %esi <== NOT EXECUTED 12066a: 6a 00 push $0x0 <== NOT EXECUTED 12066c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12066f: e8 86 98 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 120674: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120677: 85 c0 test %eax,%eax <== NOT EXECUTED 120679: 0f 85 be 00 00 00 jne 12073d <== NOT EXECUTED return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 12067f: 50 push %eax <== NOT EXECUTED 120680: 50 push %eax <== NOT EXECUTED 120681: 56 push %esi <== NOT EXECUTED 120682: 6a 02 push $0x2 <== NOT EXECUTED 120684: e8 fb 97 fe ff call 109e84 <== NOT EXECUTED if (result != 0) { 120689: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12068c: 85 c0 test %eax,%eax <== NOT EXECUTED 12068e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120691: 74 21 je 1206b4 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120693: 85 c0 test %eax,%eax <== NOT EXECUTED 120695: 0f 84 a2 00 00 00 je 12073d <== NOT EXECUTED 12069b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12069e: 85 c0 test %eax,%eax <== NOT EXECUTED 1206a0: 0f 84 97 00 00 00 je 12073d <== NOT EXECUTED 1206a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1206a9: 56 push %esi <== NOT EXECUTED 1206aa: ff d0 call *%eax <== NOT EXECUTED 1206ac: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1206af: e9 84 00 00 00 jmp 120738 <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 1206b4: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1206b7: 85 d2 test %edx,%edx <== NOT EXECUTED 1206b9: 74 41 je 1206fc <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 1206bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1206be: 56 push %esi <== NOT EXECUTED 1206bf: ff d2 call *%edx <== NOT EXECUTED 1206c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1206c4: 48 dec %eax <== NOT EXECUTED 1206c5: 74 24 je 1206eb <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1206c7: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1206ca: 85 c0 test %eax,%eax <== NOT EXECUTED 1206cc: 74 10 je 1206de <== NOT EXECUTED 1206ce: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1206d1: 85 c0 test %eax,%eax <== NOT EXECUTED 1206d3: 74 09 je 1206de <== NOT EXECUTED 1206d5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1206d8: 56 push %esi <== NOT EXECUTED 1206d9: ff d0 call *%eax <== NOT EXECUTED 1206db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 1206de: e8 bd a3 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1206e3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1206e9: eb 52 jmp 12073d <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 1206eb: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1206ee: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1206f1: 85 c0 test %eax,%eax <== NOT EXECUTED 1206f3: 75 24 jne 120719 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1206f5: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1206f8: 85 c0 test %eax,%eax <== NOT EXECUTED 1206fa: 74 10 je 12070c <== NOT EXECUTED 1206fc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1206ff: 85 c0 test %eax,%eax <== NOT EXECUTED 120701: 74 09 je 12070c <== NOT EXECUTED 120703: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120706: 56 push %esi <== NOT EXECUTED 120707: ff d0 call *%eax <== NOT EXECUTED 120709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12070c: e8 8f a3 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120711: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120717: eb 24 jmp 12073d <== NOT EXECUTED } result = (*loc.handlers->rmnod_h)( &loc ); 120719: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12071c: 56 push %esi <== NOT EXECUTED 12071d: ff d0 call *%eax <== NOT EXECUTED 12071f: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120721: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120724: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120727: 85 c0 test %eax,%eax <== NOT EXECUTED 120729: 74 15 je 120740 <== NOT EXECUTED 12072b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12072e: 85 c0 test %eax,%eax <== NOT EXECUTED 120730: 74 0e je 120740 <== NOT EXECUTED 120732: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120735: 56 push %esi <== NOT EXECUTED 120736: ff d0 call *%eax <== NOT EXECUTED 120738: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12073b: eb 03 jmp 120740 <== NOT EXECUTED 12073d: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED return result; } 120740: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120742: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120745: 5b pop %ebx <== NOT EXECUTED 120746: 5e pop %esi <== NOT EXECUTED 120747: c9 leave <== NOT EXECUTED 120748: c3 ret <== NOT EXECUTED 0010e1f0 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e1f0: 55 push %ebp <== NOT EXECUTED 10e1f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e1f3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10e1f6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e1f9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e1fc: e8 13 00 00 00 call 10e214 <== NOT EXECUTED 10e201: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 10e203: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e206: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e208: 85 d2 test %edx,%edx <== NOT EXECUTED 10e20a: 74 03 je 10e20f <== NOT EXECUTED return nap->local_value; 10e20c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED return 0; } 10e20f: c9 leave <== NOT EXECUTED 10e210: c3 ret <== NOT EXECUTED 0010e1b4 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e1b4: 55 push %ebp <== NOT EXECUTED 10e1b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e1b7: 57 push %edi <== NOT EXECUTED 10e1b8: 56 push %esi <== NOT EXECUTED 10e1b9: 53 push %ebx <== NOT EXECUTED 10e1ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e1bd: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e1c2: 31 ff xor %edi,%edi <== NOT EXECUTED 10e1c4: 31 f6 xor %esi,%esi <== NOT EXECUTED uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { if (b & remote_value) 10e1c6: 85 5d 0c test %ebx,0xc(%ebp) <== NOT EXECUTED 10e1c9: 74 10 je 10e1db <== NOT EXECUTED local_value |= rtems_assoc_local_by_remote(ap, b); 10e1cb: 50 push %eax <== NOT EXECUTED 10e1cc: 50 push %eax <== NOT EXECUTED 10e1cd: 53 push %ebx <== NOT EXECUTED 10e1ce: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e1d1: e8 1a 00 00 00 call 10e1f0 <== NOT EXECUTED 10e1d6: 09 c7 or %eax,%edi <== NOT EXECUTED 10e1d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10e1db: d1 e3 shl %ebx <== NOT EXECUTED 10e1dd: 46 inc %esi <== NOT EXECUTED 10e1de: 83 fe 20 cmp $0x20,%esi <== NOT EXECUTED 10e1e1: 75 e3 jne 10e1c6 <== NOT EXECUTED if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 10e1e3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e1e5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e1e8: 5b pop %ebx <== NOT EXECUTED 10e1e9: 5e pop %esi <== NOT EXECUTED 10e1ea: 5f pop %edi <== NOT EXECUTED 10e1eb: c9 leave <== NOT EXECUTED 10e1ec: c3 ret <== NOT EXECUTED 00114c6c : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 114c6c: 55 push %ebp <== NOT EXECUTED 114c6d: 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; } 114c6f: b8 0c 61 12 00 mov $0x12610c,%eax <== NOT EXECUTED 114c74: c9 leave <== NOT EXECUTED 114c75: c3 ret <== NOT EXECUTED 001119d4 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1119d4: 55 push %ebp <== NOT EXECUTED 1119d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1119d7: 53 push %ebx <== NOT EXECUTED 1119d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1119db: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 1119de: 53 push %ebx <== NOT EXECUTED 1119df: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1119e2: e8 1d 00 00 00 call 111a04 <== NOT EXECUTED if (nap) 1119e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1119ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1119ec: 74 07 je 1119f5 <== NOT EXECUTED return nap->name; 1119ee: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 1119f0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1119f3: c9 leave <== NOT EXECUTED 1119f4: c3 ret <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 1119f5: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 1119f8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1119fb: 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); 1119fc: e9 6b 32 00 00 jmp 114c6c <== NOT EXECUTED 0010e650 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10e650: 55 push %ebp <== NOT EXECUTED 10e651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e653: 56 push %esi <== NOT EXECUTED 10e654: 53 push %ebx <== NOT EXECUTED 10e655: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e658: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10e65b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e65d: 85 c0 test %eax,%eax <== NOT EXECUTED 10e65f: 74 1b je 10e67c <== NOT EXECUTED 10e661: 52 push %edx <== NOT EXECUTED 10e662: 52 push %edx <== NOT EXECUTED 10e663: 68 05 6e 11 00 push $0x116e05 <== NOT EXECUTED 10e668: 50 push %eax <== NOT EXECUTED 10e669: e8 3e 11 00 00 call 10f7ac <== NOT EXECUTED 10e66e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e671: 85 c0 test %eax,%eax <== NOT EXECUTED 10e673: 75 07 jne 10e67c <== NOT EXECUTED default_ap = ap++; 10e675: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e677: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e67a: eb 0c jmp 10e688 <== NOT EXECUTED 10e67c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e67e: eb 08 jmp 10e688 <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->local_value == local_value) 10e680: 39 73 04 cmp %esi,0x4(%ebx) <== NOT EXECUTED 10e683: 74 0a je 10e68f <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10e685: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e688: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10e68b: 75 f3 jne 10e680 <== NOT EXECUTED 10e68d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 10e68f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e691: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e694: 5b pop %ebx <== NOT EXECUTED 10e695: 5e pop %esi <== NOT EXECUTED 10e696: c9 leave <== NOT EXECUTED 10e697: c3 ret <== NOT EXECUTED 0010e214 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e214: 55 push %ebp <== NOT EXECUTED 10e215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e217: 56 push %esi <== NOT EXECUTED 10e218: 53 push %ebx <== NOT EXECUTED 10e219: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e21c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10e21f: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e221: 85 c0 test %eax,%eax <== NOT EXECUTED 10e223: 74 1b je 10e240 <== NOT EXECUTED 10e225: 52 push %edx <== NOT EXECUTED 10e226: 52 push %edx <== NOT EXECUTED 10e227: 68 05 6e 11 00 push $0x116e05 <== NOT EXECUTED 10e22c: 50 push %eax <== NOT EXECUTED 10e22d: e8 7a 15 00 00 call 10f7ac <== NOT EXECUTED 10e232: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e235: 85 c0 test %eax,%eax <== NOT EXECUTED 10e237: 75 07 jne 10e240 <== NOT EXECUTED default_ap = ap++; 10e239: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e23b: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e23e: eb 0c jmp 10e24c <== NOT EXECUTED 10e240: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e242: eb 08 jmp 10e24c <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->remote_value == remote_value) 10e244: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10e247: 74 0a je 10e253 <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10e249: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e24c: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10e24f: 75 f3 jne 10e244 <== NOT EXECUTED 10e251: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (ap->remote_value == remote_value) return ap; return default_ap; } 10e253: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e255: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e258: 5b pop %ebx <== NOT EXECUTED 10e259: 5e pop %esi <== NOT EXECUTED 10e25a: c9 leave <== NOT EXECUTED 10e25b: c3 ret <== NOT EXECUTED 0010e25c : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10e25c: 55 push %ebp <== NOT EXECUTED 10e25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e25f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10e262: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e265: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e268: e8 e3 03 00 00 call 10e650 <== NOT EXECUTED 10e26d: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 10e26f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e272: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e274: 85 d2 test %edx,%edx <== NOT EXECUTED 10e276: 74 03 je 10e27b <== NOT EXECUTED return nap->remote_value; 10e278: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED return 0; } 10e27b: c9 leave <== NOT EXECUTED 10e27c: c3 ret <== NOT EXECUTED 0010953c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 10953c: 55 push %ebp <== NOT EXECUTED 10953d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10953f: 57 push %edi <== NOT EXECUTED 109540: 56 push %esi <== NOT EXECUTED 109541: 53 push %ebx <== NOT EXECUTED 109542: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109545: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109548: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10954b: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10954e: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109553: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 109557: 0f 84 90 00 00 00 je 1095ed <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10955d: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109562: 85 ff test %edi,%edi <== NOT EXECUTED 109564: 0f 84 83 00 00 00 je 1095ed <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 10956a: f7 c6 10 00 00 00 test $0x10,%esi <== NOT EXECUTED 109570: 74 12 je 109584 <== NOT EXECUTED the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 109572: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 109577: 85 d2 test %edx,%edx <== NOT EXECUTED 109579: 74 72 je 1095ed <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10957b: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 109582: eb 07 jmp 10958b <== NOT EXECUTED if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 109584: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) <== NOT EXECUTED the_attributes.maximum_count = maximum_waiters; 10958b: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10958e: a1 f4 f4 11 00 mov 0x11f4f4,%eax <== NOT EXECUTED 109593: 40 inc %eax <== NOT EXECUTED 109594: a3 f4 f4 11 00 mov %eax,0x11f4f4 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109599: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10959c: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 1095a1: e8 c2 1a 00 00 call 10b068 <_Objects_Allocate> <== NOT EXECUTED 1095a6: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 1095a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1095ab: 85 c0 test %eax,%eax <== NOT EXECUTED 1095ad: 75 0c jne 1095bb <== NOT EXECUTED _Thread_Enable_dispatch(); 1095af: e8 b8 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1095b4: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 1095b9: eb 32 jmp 1095ed <== NOT EXECUTED return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 1095bb: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 1095be: 50 push %eax <== NOT EXECUTED 1095bf: 50 push %eax <== NOT EXECUTED 1095c0: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 1095c3: 50 push %eax <== NOT EXECUTED 1095c4: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1095c7: 50 push %eax <== NOT EXECUTED 1095c8: e8 67 12 00 00 call 10a834 <_CORE_barrier_Initialize> <== NOT EXECUTED 1095cd: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1095d0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1095d3: a1 18 f4 11 00 mov 0x11f418,%eax <== NOT EXECUTED 1095d8: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1095db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1095de: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 1095e1: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1095e3: e8 84 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1095e8: 31 c0 xor %eax,%eax <== NOT EXECUTED 1095ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1095ed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1095f0: 5b pop %ebx <== NOT EXECUTED 1095f1: 5e pop %esi <== NOT EXECUTED 1095f2: 5f pop %edi <== NOT EXECUTED 1095f3: c9 leave <== NOT EXECUTED 1095f4: c3 ret <== NOT EXECUTED 001095f8 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 1095f8: 55 push %ebp <== NOT EXECUTED 1095f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095fb: 53 push %ebx <== NOT EXECUTED 1095fc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1095ff: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109602: 50 push %eax <== NOT EXECUTED 109603: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109606: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10960b: e8 9c 1e 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 109610: 89 c3 mov %eax,%ebx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 109612: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109615: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10961a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10961e: 75 32 jne 109652 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Flush( 109620: 50 push %eax <== NOT EXECUTED 109621: 6a 02 push $0x2 <== NOT EXECUTED 109623: 6a 00 push $0x0 <== NOT EXECUTED 109625: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109628: 50 push %eax <== NOT EXECUTED 109629: e8 9a 2c 00 00 call 10c2c8 <_Thread_queue_Flush> <== NOT EXECUTED &the_barrier->Barrier, NULL, CORE_BARRIER_WAS_DELETED ); _Objects_Close( &_Barrier_Information, &the_barrier->Object ); 10962e: 59 pop %ecx <== NOT EXECUTED 10962f: 58 pop %eax <== NOT EXECUTED 109630: 53 push %ebx <== NOT EXECUTED 109631: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 109636: e8 a1 1a 00 00 call 10b0dc <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10963b: 58 pop %eax <== NOT EXECUTED 10963c: 5a pop %edx <== NOT EXECUTED 10963d: 53 push %ebx <== NOT EXECUTED 10963e: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 109643: e8 30 1d 00 00 call 10b378 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 109648: e8 1f 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10964d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10964f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109652: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109655: c9 leave <== NOT EXECUTED 109656: c3 ret <== NOT EXECUTED 00109658 : rtems_status_code rtems_barrier_ident( rtems_name name, rtems_id *id ) { 109658: 55 push %ebp <== NOT EXECUTED 109659: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10965b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10965e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109661: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 109666: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109669: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10966e: e8 81 1f 00 00 call 10b5f4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109673: 8b 04 85 30 94 11 00 mov 0x119430(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10967a: c9 leave <== NOT EXECUTED 10967b: c3 ret <== NOT EXECUTED 0010967c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 10967c: 55 push %ebp <== NOT EXECUTED 10967d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10967f: 56 push %esi <== NOT EXECUTED 109680: 53 push %ebx <== NOT EXECUTED 109681: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109684: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109687: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10968a: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10968f: 85 f6 test %esi,%esi <== NOT EXECUTED 109691: 74 39 je 1096cc <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 109693: 52 push %edx <== NOT EXECUTED 109694: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109697: 50 push %eax <== NOT EXECUTED 109698: 53 push %ebx <== NOT EXECUTED 109699: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10969e: e8 09 1e 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 1096a3: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 1096a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096a8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1096ad: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1096b1: 75 19 jne 1096cc <== NOT EXECUTED case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 1096b3: 50 push %eax <== NOT EXECUTED 1096b4: 6a 00 push $0x0 <== NOT EXECUTED 1096b6: 53 push %ebx <== NOT EXECUTED 1096b7: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 1096ba: 50 push %eax <== NOT EXECUTED 1096bb: e8 a8 11 00 00 call 10a868 <_CORE_barrier_Release> <== NOT EXECUTED 1096c0: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1096c2: e8 a5 25 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1096c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 1096c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1096cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1096cf: 5b pop %ebx <== NOT EXECUTED 1096d0: 5e pop %esi <== NOT EXECUTED 1096d1: c9 leave <== NOT EXECUTED 1096d2: c3 ret <== NOT EXECUTED 001096d4 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 1096d4: 55 push %ebp <== NOT EXECUTED 1096d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1096d7: 53 push %ebx <== NOT EXECUTED 1096d8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 1096db: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1096de: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1096e1: 50 push %eax <== NOT EXECUTED 1096e2: 53 push %ebx <== NOT EXECUTED 1096e3: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 1096e8: e8 bf 1d 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 1096ed: 89 c2 mov %eax,%edx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 1096ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096f2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1096f7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1096fb: 75 2f jne 10972c <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 1096fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109700: 6a 00 push $0x0 <== NOT EXECUTED 109702: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109705: 6a 01 push $0x1 <== NOT EXECUTED 109707: 53 push %ebx <== NOT EXECUTED 109708: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10970b: 50 push %eax <== NOT EXECUTED 10970c: e8 87 11 00 00 call 10a898 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 109711: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109714: e8 53 25 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 109719: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10971c: a1 b4 f5 11 00 mov 0x11f5b4,%eax <== NOT EXECUTED 109721: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109724: e8 6b 4a 00 00 call 10e194 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 109729: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10972c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10972f: c9 leave <== NOT EXECUTED 109730: c3 ret <== NOT EXECUTED 0010a318 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10a318: 55 push %ebp <== NOT EXECUTED 10a319: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a31b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a31e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a321: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10a324: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10a327: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a32a: 09 d0 or %edx,%eax <== NOT EXECUTED 10a32c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10a32f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10a332: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10a334: c9 leave <== NOT EXECUTED 10a335: c3 ret <== NOT EXECUTED 0010a338 : char C1, char C2, char C3, char C4 ) { 10a338: 55 push %ebp <== NOT EXECUTED 10a339: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a33b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10a33f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10a342: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10a346: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a349: 09 d0 or %edx,%eax <== NOT EXECUTED 10a34b: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10a34f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10a352: 09 d0 or %edx,%eax <== NOT EXECUTED 10a354: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10a358: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10a35a: c9 leave <== NOT EXECUTED 10a35b: c3 ret <== NOT EXECUTED 00108958 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 108958: 55 push %ebp <== NOT EXECUTED 108959: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10895b: 53 push %ebx <== NOT EXECUTED 10895c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10895f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108962: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !time_buffer ) 108965: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10896a: 85 db test %ebx,%ebx <== NOT EXECUTED 10896c: 74 44 je 1089b2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; switch ( option ) { 10896e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108973: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 108976: 77 3a ja 1089b2 <== NOT EXECUTED 108978: ff 24 95 a4 67 11 00 jmp *0x1167a4(,%edx,4) <== NOT EXECUTED case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 10897f: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 108982: 58 pop %eax <== NOT EXECUTED 108983: 5b pop %ebx <== NOT EXECUTED 108984: c9 leave <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 108985: e9 76 00 00 00 jmp 108a00 <== NOT EXECUTED case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 10898a: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 10898d: 5b pop %ebx <== NOT EXECUTED 10898e: 5b pop %ebx <== NOT EXECUTED 10898f: c9 leave <== NOT EXECUTED switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 108990: e9 23 00 00 00 jmp 1089b8 <== NOT EXECUTED case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 108995: e8 5a 00 00 00 call 1089f4 <== NOT EXECUTED 10899a: eb 05 jmp 1089a1 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 10899c: e8 3f 00 00 00 call 1089e0 <== NOT EXECUTED 1089a1: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1089a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1089a5: eb 0b jmp 1089b2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089a7: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 1089aa: 59 pop %ecx <== NOT EXECUTED 1089ab: 5b pop %ebx <== NOT EXECUTED 1089ac: c9 leave <== NOT EXECUTED *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089ad: e9 ea 00 00 00 jmp 108a9c <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 1089b2: 5a pop %edx <== NOT EXECUTED 1089b3: 5b pop %ebx <== NOT EXECUTED 1089b4: c9 leave <== NOT EXECUTED 1089b5: c3 ret <== NOT EXECUTED 001089b8 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 1089b8: 55 push %ebp <== NOT EXECUTED 1089b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089bb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_interval ) 1089be: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1089c3: 85 d2 test %edx,%edx <== NOT EXECUTED 1089c5: 74 17 je 1089de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 1089c7: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 1089cc: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 1089d3: 74 09 je 1089de <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 1089d5: a1 90 ca 11 00 mov 0x11ca90,%eax <== NOT EXECUTED 1089da: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1089dc: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1089de: c9 leave <== NOT EXECUTED 1089df: c3 ret <== NOT EXECUTED 001089e0 : #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 1089e0: 55 push %ebp <== NOT EXECUTED 1089e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089e3: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 1089e8: 31 d2 xor %edx,%edx <== NOT EXECUTED 1089ea: f7 35 9c cb 11 00 divl 0x11cb9c <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; } 1089f0: c9 leave <== NOT EXECUTED 1089f1: c3 ret <== NOT EXECUTED 001089f4 : #include #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { 1089f4: 55 push %ebp <== NOT EXECUTED 1089f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Watchdog_Ticks_since_boot; 1089f7: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED } 1089fc: c9 leave <== NOT EXECUTED 1089fd: c3 ret <== NOT EXECUTED 00108a00 : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 108a00: 55 push %ebp <== NOT EXECUTED 108a01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a03: 56 push %esi <== NOT EXECUTED 108a04: 53 push %ebx <== NOT EXECUTED 108a05: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 108a08: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 108a0b: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108a10: 85 f6 test %esi,%esi <== NOT EXECUTED 108a12: 74 7f je 108a93 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108a14: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 108a19: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 108a20: 74 71 je 108a93 <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108a22: 9c pushf <== NOT EXECUTED 108a23: fa cli <== NOT EXECUTED 108a24: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 108a25: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108a28: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 108a2b: 50 push %eax <== NOT EXECUTED 108a2c: e8 3f 14 00 00 call 109e70 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 108a31: 53 push %ebx <== NOT EXECUTED 108a32: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 108a33: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108a36: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 108a39: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 108a3c: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 108a41: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a43: f7 f1 div %ecx <== NOT EXECUTED 108a45: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 108a48: 58 pop %eax <== NOT EXECUTED 108a49: 5a pop %edx <== NOT EXECUTED 108a4a: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 108a4d: 50 push %eax <== NOT EXECUTED 108a4e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108a51: 50 push %eax <== NOT EXECUTED 108a52: e8 a1 63 00 00 call 10edf8 <== NOT EXECUTED /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 108a57: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108a5a: 05 6c 07 00 00 add $0x76c,%eax <== NOT EXECUTED 108a5f: 89 06 mov %eax,(%esi) <== NOT EXECUTED tmbuf->month = time.tm_mon + 1; 108a61: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 108a64: 40 inc %eax <== NOT EXECUTED 108a65: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED tmbuf->day = time.tm_mday; 108a68: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 108a6b: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED tmbuf->hour = time.tm_hour; 108a6e: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 108a71: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED tmbuf->minute = time.tm_min; 108a74: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 108a77: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED tmbuf->second = time.tm_sec; 108a7a: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 108a7d: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 108a80: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 108a83: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a85: f7 35 9c cb 11 00 divl 0x11cb9c <== NOT EXECUTED 108a8b: 89 46 18 mov %eax,0x18(%esi) <== NOT EXECUTED 108a8e: 31 c0 xor %eax,%eax <== NOT EXECUTED 108a90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108a93: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108a96: 5b pop %ebx <== NOT EXECUTED 108a97: 5e pop %esi <== NOT EXECUTED 108a98: c9 leave <== NOT EXECUTED 108a99: c3 ret <== NOT EXECUTED 00108a9c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 108a9c: 55 push %ebp <== NOT EXECUTED 108a9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a9f: 56 push %esi <== NOT EXECUTED 108aa0: 53 push %ebx <== NOT EXECUTED 108aa1: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 108aa4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED if ( !time ) 108aa7: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108aac: 85 f6 test %esi,%esi <== NOT EXECUTED 108aae: 74 38 je 108ae8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108ab0: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 108ab5: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 108abc: 74 2a je 108ae8 <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108abe: 9c pushf <== NOT EXECUTED 108abf: fa cli <== NOT EXECUTED 108ac0: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 108ac1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ac4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108ac7: 50 push %eax <== NOT EXECUTED 108ac8: e8 a3 13 00 00 call 109e70 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 108acd: 53 push %ebx <== NOT EXECUTED 108ace: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 108acf: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 108ad2: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 108ad4: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 108ad7: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 108adc: 31 d2 xor %edx,%edx <== NOT EXECUTED 108ade: f7 f1 div %ecx <== NOT EXECUTED 108ae0: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 108ae3: 31 c0 xor %eax,%eax <== NOT EXECUTED 108ae5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 108ae8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108aeb: 5b pop %ebx <== NOT EXECUTED 108aec: 5e pop %esi <== NOT EXECUTED 108aed: c9 leave <== NOT EXECUTED 108aee: c3 ret <== NOT EXECUTED 00108cf0 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 108cf0: 55 push %ebp <== NOT EXECUTED 108cf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108cf3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108cf6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !uptime ) 108cf9: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108cfe: 85 d2 test %edx,%edx <== NOT EXECUTED 108d00: 74 0e je 108d10 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 108d02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d05: 52 push %edx <== NOT EXECUTED 108d06: e8 e5 14 00 00 call 10a1f0 <_TOD_Get_uptime> <== NOT EXECUTED 108d0b: 31 c0 xor %eax,%eax <== NOT EXECUTED 108d0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108d10: c9 leave <== NOT EXECUTED 108d11: c3 ret <== NOT EXECUTED 00109924 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 109924: 55 push %ebp <== NOT EXECUTED 109925: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109927: 53 push %ebx <== NOT EXECUTED 109928: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10992b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED struct timespec newtime; if ( !time_buffer ) 10992e: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 109933: 85 db test %ebx,%ebx <== NOT EXECUTED 109935: 74 54 je 10998b <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 109937: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10993a: 53 push %ebx <== NOT EXECUTED 10993b: e8 f8 00 00 00 call 109a38 <_TOD_Validate> <== NOT EXECUTED 109940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109943: ba 14 00 00 00 mov $0x14,%edx <== NOT EXECUTED 109948: 84 c0 test %al,%al <== NOT EXECUTED 10994a: 74 3f je 10998b <== NOT EXECUTED newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10994c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10994f: 53 push %ebx <== NOT EXECUTED 109950: e8 7b 00 00 00 call 1099d0 <_TOD_To_seconds> <== NOT EXECUTED 109955: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED newtime.tv_nsec = time_buffer->ticks * 109958: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10995b: 0f af 05 58 85 12 00 imul 0x128558,%eax <== NOT EXECUTED 109962: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax <== NOT EXECUTED 109968: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10996b: a1 bc 83 12 00 mov 0x1283bc,%eax <== NOT EXECUTED 109970: 40 inc %eax <== NOT EXECUTED 109971: a3 bc 83 12 00 mov %eax,0x1283bc <== NOT EXECUTED (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 109976: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109979: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10997c: e8 73 17 00 00 call 10b0f4 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 109981: e8 ba 27 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 109986: 31 d2 xor %edx,%edx <== NOT EXECUTED 109988: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10998b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10998d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109990: c9 leave <== NOT EXECUTED 109991: c3 ret <== NOT EXECUTED 00108af0 : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 108af0: 55 push %ebp <== NOT EXECUTED 108af1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108af3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !routine ) 108af6: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108afb: 85 d2 test %edx,%edx <== NOT EXECUTED 108afd: 74 08 je 108b07 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 108aff: 89 15 a4 cb 11 00 mov %edx,0x11cba4 <== NOT EXECUTED 108b05: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108b07: c9 leave <== NOT EXECUTED 108b08: c3 ret <== NOT EXECUTED 00108b0c : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 108b0c: 55 push %ebp <== NOT EXECUTED 108b0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b0f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _TOD_Tickle_ticks(); 108b12: e8 e9 13 00 00 call 109f00 <_TOD_Tickle_ticks> <== NOT EXECUTED * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if 108b17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108b1a: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 108b1f: e8 b8 31 00 00 call 10bcdc <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 108b24: e8 fb 2c 00 00 call 10b824 <_Thread_Tickle_timeslice> <== NOT EXECUTED 108b29: a0 d0 ca 11 00 mov 0x11cad0,%al <== NOT EXECUTED if ( _Thread_Is_context_switch_necessary() && 108b2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108b31: 84 c0 test %al,%al <== NOT EXECUTED 108b33: 74 0e je 108b43 <== NOT EXECUTED 108b35: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108b3a: 85 c0 test %eax,%eax <== NOT EXECUTED 108b3c: 75 05 jne 108b43 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 108b3e: e8 39 21 00 00 call 10ac7c <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108b43: 31 c0 xor %eax,%eax <== NOT EXECUTED 108b45: c9 leave <== NOT EXECUTED 108b46: c3 ret <== NOT EXECUTED 00106cd6 : void rtems_cpu_usage_report( void ) { 106cd6: 55 push %ebp <== NOT EXECUTED 106cd7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106cd9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_cpu_usage_report_with_plugin( NULL, printk_plugin ); 106cdc: 68 4c 7e 10 00 push $0x107e4c <== NOT EXECUTED 106ce1: 6a 00 push $0x0 <== NOT EXECUTED 106ce3: e8 90 fe ff ff call 106b78 <== NOT EXECUTED 106ce8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 106ceb: c9 leave <== NOT EXECUTED 106cec: c3 ret <== NOT EXECUTED 00106b78 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 106b78: 55 push %ebp <== NOT EXECUTED 106b79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106b7b: 57 push %edi <== NOT EXECUTED 106b7c: 56 push %esi <== NOT EXECUTED 106b7d: 53 push %ebx <== NOT EXECUTED 106b7e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 106b81: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 106b85: 0f 84 43 01 00 00 je 106cce <== NOT EXECUTED * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); 106b8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106b8e: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 106b91: 53 push %ebx <== NOT EXECUTED 106b92: e8 cd 44 00 00 call 10b064 <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 106b97: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 106b9a: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 106b9d: 50 push %eax <== NOT EXECUTED 106b9e: 53 push %ebx <== NOT EXECUTED 106b9f: 68 58 86 12 00 push $0x128658 <== NOT EXECUTED 106ba4: e8 4b 63 00 00 call 10cef4 <_Timespec_Subtract> <== NOT EXECUTED } } } #endif (*print)( context, "CPU Usage by thread\n" 106ba9: 58 pop %eax <== NOT EXECUTED 106baa: 5a pop %edx <== NOT EXECUTED 106bab: 68 76 92 11 00 push $0x119276 <== NOT EXECUTED 106bb0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106bb3: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 106bb6: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 106bbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 106bbe: 8b 04 bd 90 83 12 00 mov 0x128390(,%edi,4),%eax <== NOT EXECUTED 106bc5: 85 c0 test %eax,%eax <== NOT EXECUTED 106bc7: 0f 84 d9 00 00 00 je 106ca6 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 106bcd: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 106bd0: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED if ( information ) { 106bd3: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 106bd8: 85 c0 test %eax,%eax <== NOT EXECUTED 106bda: 0f 85 b7 00 00 00 jne 106c97 <== NOT EXECUTED 106be0: e9 c1 00 00 00 jmp 106ca6 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 106be5: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED 106be8: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 106beb: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED if ( !the_thread ) 106bee: 85 db test %ebx,%ebx <== NOT EXECUTED 106bf0: 0f 84 a0 00 00 00 je 106c96 <== NOT EXECUTED continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 106bf6: 50 push %eax <== NOT EXECUTED 106bf7: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 106bfa: 50 push %eax <== NOT EXECUTED 106bfb: 6a 0d push $0xd <== NOT EXECUTED 106bfd: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 106c00: e8 73 32 00 00 call 109e78 <== NOT EXECUTED (*print)( 106c05: 8d 55 bf lea -0x41(%ebp),%edx <== NOT EXECUTED 106c08: 52 push %edx <== NOT EXECUTED 106c09: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 106c0c: 68 bb 92 11 00 push $0x1192bb <== NOT EXECUTED 106c11: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106c14: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 106c17: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 106c1d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 106c23: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 106c26: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 106c29: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 106c2c: a1 7c 84 12 00 mov 0x12847c,%eax <== NOT EXECUTED 106c31: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 106c34: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 106c37: 75 22 jne 106c5b <== NOT EXECUTED struct timespec used; _Timespec_Subtract( 106c39: 50 push %eax <== NOT EXECUTED 106c3a: 8d 5d cc lea -0x34(%ebp),%ebx <== NOT EXECUTED 106c3d: 53 push %ebx <== NOT EXECUTED 106c3e: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 106c41: 50 push %eax <== NOT EXECUTED 106c42: 68 84 84 12 00 push $0x128484 <== NOT EXECUTED 106c47: e8 a8 62 00 00 call 10cef4 <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 106c4c: 59 pop %ecx <== NOT EXECUTED 106c4d: 58 pop %eax <== NOT EXECUTED 106c4e: 53 push %ebx <== NOT EXECUTED 106c4f: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 106c52: 50 push %eax <== NOT EXECUTED 106c53: e8 b0 61 00 00 call 10ce08 <_Timespec_Add_to> <== NOT EXECUTED 106c58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED }; _Timespec_Divide( &ran, &total, &ival, &fval ); 106c5b: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 106c5e: 50 push %eax <== NOT EXECUTED 106c5f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 106c62: 50 push %eax <== NOT EXECUTED 106c63: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 106c66: 50 push %eax <== NOT EXECUTED 106c67: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 106c6a: 50 push %eax <== NOT EXECUTED 106c6b: e8 c8 61 00 00 call 10ce38 <_Timespec_Divide> <== NOT EXECUTED /* * Print the information */ (*print)( context, 106c70: 58 pop %eax <== NOT EXECUTED 106c71: 5a pop %edx <== NOT EXECUTED 106c72: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 106c75: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 106c78: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 106c7b: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 106c80: 31 d2 xor %edx,%edx <== NOT EXECUTED 106c82: f7 f1 div %ecx <== NOT EXECUTED 106c84: 50 push %eax <== NOT EXECUTED 106c85: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 106c88: 68 ce 92 11 00 push $0x1192ce <== NOT EXECUTED 106c8d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106c90: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 106c93: 83 c4 20 add $0x20,%esp <== NOT EXECUTED api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 106c96: 46 inc %esi <== NOT EXECUTED 106c97: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED 106c9a: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 106c9e: 39 c6 cmp %eax,%esi <== NOT EXECUTED 106ca0: 0f 86 3f ff ff ff jbe 106be5 <== NOT EXECUTED #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 106ca6: 47 inc %edi <== NOT EXECUTED " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 106ca7: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 106caa: 0f 85 0e ff ff ff jne 106bbe <== NOT EXECUTED } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 106cb0: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 106cb3: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 106cb8: 31 d2 xor %edx,%edx <== NOT EXECUTED 106cba: f7 f1 div %ecx <== NOT EXECUTED 106cbc: 50 push %eax <== NOT EXECUTED 106cbd: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 106cc0: 68 e6 92 11 00 push $0x1192e6 <== NOT EXECUTED 106cc5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106cc8: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 106ccb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED "Ticks since last reset = %" PRId32 "\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset ); (*print)( context, "Total Units = %" PRId32 "\n", total_units ); #endif } 106cce: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106cd1: 5b pop %ebx <== NOT EXECUTED 106cd2: 5e pop %esi <== NOT EXECUTED 106cd3: 5f pop %edi <== NOT EXECUTED 106cd4: c9 leave <== NOT EXECUTED 106cd5: c3 ret <== NOT EXECUTED 00106d0c : /* * rtems_cpu_usage_reset */ void rtems_cpu_usage_reset( void ) { 106d0c: 55 push %ebp <== NOT EXECUTED 106d0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d0f: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset ); 106d12: 68 58 86 12 00 push $0x128658 <== NOT EXECUTED 106d17: e8 48 43 00 00 call 10b064 <_TOD_Get_uptime> <== NOT EXECUTED _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset; 106d1c: a1 58 86 12 00 mov 0x128658,%eax <== NOT EXECUTED 106d21: 8b 15 5c 86 12 00 mov 0x12865c,%edx <== NOT EXECUTED 106d27: a3 84 84 12 00 mov %eax,0x128484 <== NOT EXECUTED 106d2c: 89 15 88 84 12 00 mov %edx,0x128488 <== NOT EXECUTED #else CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot; #endif rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler); 106d32: c7 04 24 f0 6c 10 00 movl $0x106cf0,(%esp) <== NOT EXECUTED 106d39: e8 ce 46 00 00 call 10b40c <== NOT EXECUTED 106d3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 106d41: c9 leave <== NOT EXECUTED 106d42: c3 ret <== NOT EXECUTED 0010d5ed : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10d5ed: 55 push %ebp <== NOT EXECUTED 10d5ee: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5f0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10d5f3: f7 d0 not %eax <== NOT EXECUTED 10d5f5: 21 05 c4 ca 11 00 and %eax,0x11cac4 <== NOT EXECUTED } 10d5fb: c9 leave <== NOT EXECUTED 10d5fc: c3 ret <== NOT EXECUTED 0010d5df : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10d5df: 55 push %ebp <== NOT EXECUTED 10d5e0: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10d5e2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d5e5: 09 05 c4 ca 11 00 or %eax,0x11cac4 <== NOT EXECUTED } 10d5eb: c9 leave <== NOT EXECUTED 10d5ec: c3 ret <== NOT EXECUTED 0010dea3 : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 10dea3: 55 push %ebp <== NOT EXECUTED 10dea4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dea6: 53 push %ebx <== NOT EXECUTED 10dea7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 10deaa: 50 push %eax <== NOT EXECUTED 10deab: 68 dc 6c 11 00 push $0x116cdc <== NOT EXECUTED 10deb0: e8 a7 03 00 00 call 10e25c <== NOT EXECUTED 10deb5: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10deb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10deba: 85 c0 test %eax,%eax <== NOT EXECUTED 10debc: 74 07 je 10dec5 <== NOT EXECUTED { errno = rc; 10debe: e8 ed 07 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10dec3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 10dec5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10dec8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10decb: c9 leave <== NOT EXECUTED 10decc: c3 ret <== NOT EXECUTED 001095a8 : int rtems_error( int error_flag, const char *printf_format, ... ) { 1095a8: 55 push %ebp <== NOT EXECUTED 1095a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1095ae: 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); 1095b1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1095b4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1095b7: e8 6d fe ff ff call 109429 <== NOT EXECUTED va_end(arglist); return chars_written; } 1095bc: c9 leave <== NOT EXECUTED 1095bd: c3 ret <== NOT EXECUTED 00108b48 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108b48: 55 push %ebp <== NOT EXECUTED 108b49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b4b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108b4e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108b51: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED RTEMS_API_Control *api; if ( !event_out ) 108b54: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108b59: 85 d2 test %edx,%edx <== NOT EXECUTED 108b5b: 74 3f je 108b9c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 108b5d: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 108b62: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED if ( _Event_sets_Is_empty( event_in ) ) { 108b68: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108b6a: 75 08 jne 108b74 <== NOT EXECUTED *event_out = api->pending_events; 108b6c: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108b6e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 108b70: 31 c0 xor %eax,%eax <== NOT EXECUTED 108b72: eb 28 jmp 108b9c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108b74: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108b79: 40 inc %eax <== NOT EXECUTED 108b7a: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 108b7f: 52 push %edx <== NOT EXECUTED 108b80: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108b83: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108b86: 51 push %ecx <== NOT EXECUTED 108b87: e8 14 00 00 00 call 108ba0 <_Event_Seize> <== NOT EXECUTED _Thread_Enable_dispatch(); 108b8c: e8 2f 22 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 108b91: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 108b96: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 108b99: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108b9c: c9 leave <== NOT EXECUTED 108b9d: c3 ret <== NOT EXECUTED 00108cb8 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 108cb8: 55 push %ebp <== NOT EXECUTED 108cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108cbb: 53 push %ebx <== NOT EXECUTED 108cbc: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 108cbf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 108cc2: 50 push %eax <== NOT EXECUTED 108cc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108cc6: e8 15 21 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 108ccb: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 108ccd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108cd0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 108cd5: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 108cd9: 75 23 jne 108cfe <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 108cdb: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax <== NOT EXECUTED * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, 108ce1: 9c pushf <== NOT EXECUTED 108ce2: fa cli <== NOT EXECUTED 108ce3: 59 pop %ecx <== NOT EXECUTED void *starting_address, 108ce4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 108ce7: 09 10 or %edx,(%eax) <== NOT EXECUTED size_t size, 108ce9: 51 push %ecx <== NOT EXECUTED 108cea: 9d popf <== NOT EXECUTED _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 108ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108cee: 53 push %ebx <== NOT EXECUTED 108cef: e8 10 00 00 00 call 108d04 <_Event_Surrender> <== NOT EXECUTED _Thread_Enable_dispatch(); 108cf4: e8 c7 20 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 108cf9: 31 c0 xor %eax,%eax <== NOT EXECUTED 108cfb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 108cfe: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108d01: c9 leave <== NOT EXECUTED 108d02: c3 ret <== NOT EXECUTED 0010ccd4 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10ccd4: 55 push %ebp <== NOT EXECUTED 10ccd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccd7: 57 push %edi <== NOT EXECUTED 10ccd8: 56 push %esi <== NOT EXECUTED 10ccd9: 53 push %ebx <== NOT EXECUTED 10ccda: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccdd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cce0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10cce3: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10cce8: 85 f6 test %esi,%esi <== NOT EXECUTED 10ccea: 74 61 je 10cd4d <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10ccec: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10ccf1: 85 ff test %edi,%edi <== NOT EXECUTED 10ccf3: 74 58 je 10cd4d <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ccf5: a1 84 88 12 00 mov 0x128884,%eax <== NOT EXECUTED 10ccfa: 40 inc %eax <== NOT EXECUTED 10ccfb: a3 84 88 12 00 mov %eax,0x128884 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10cd00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd03: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd08: e8 2b 0b 00 00 call 10d838 <_Objects_Allocate> <== NOT EXECUTED 10cd0d: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10cd0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd12: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd14: 75 0c jne 10cd22 <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd16: e8 21 17 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd1b: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10cd20: eb 2b jmp 10cd4d <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10cd22: 50 push %eax <== NOT EXECUTED 10cd23: 50 push %eax <== NOT EXECUTED 10cd24: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cd27: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd2a: 50 push %eax <== NOT EXECUTED 10cd2b: e8 c8 22 00 00 call 10eff8 <_User_extensions_Add_set> <== NOT EXECUTED 10cd30: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10cd33: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10cd36: a1 d0 8a 12 00 mov 0x128ad0,%eax <== NOT EXECUTED 10cd3b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10cd3e: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10cd41: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd43: e8 f4 16 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd48: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cd4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10cd4d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd50: 5b pop %ebx <== NOT EXECUTED 10cd51: 5e pop %esi <== NOT EXECUTED 10cd52: 5f pop %edi <== NOT EXECUTED 10cd53: c9 leave <== NOT EXECUTED 10cd54: c3 ret <== NOT EXECUTED 0010cd58 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10cd58: 55 push %ebp <== NOT EXECUTED 10cd59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd5b: 53 push %ebx <== NOT EXECUTED 10cd5c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10cd5f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cd62: 50 push %eax <== NOT EXECUTED 10cd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cd66: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd6b: e8 0c 0f 00 00 call 10dc7c <_Objects_Get> <== NOT EXECUTED 10cd70: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10cd72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd75: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10cd7a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10cd7e: 75 30 jne 10cdb0 <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10cd80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd83: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd86: 50 push %eax <== NOT EXECUTED 10cd87: e8 54 23 00 00 call 10f0e0 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10cd8c: 59 pop %ecx <== NOT EXECUTED 10cd8d: 58 pop %eax <== NOT EXECUTED 10cd8e: 53 push %ebx <== NOT EXECUTED 10cd8f: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd94: e8 13 0b 00 00 call 10d8ac <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10cd99: 58 pop %eax <== NOT EXECUTED 10cd9a: 5a pop %edx <== NOT EXECUTED 10cd9b: 53 push %ebx <== NOT EXECUTED 10cd9c: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cda1: e8 a2 0d 00 00 call 10db48 <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10cda6: e8 91 16 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cdab: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cdad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cdb0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cdb3: c9 leave <== NOT EXECUTED 10cdb4: c3 ret <== NOT EXECUTED 0010afdc : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10afdc: 55 push %ebp <== NOT EXECUTED 10afdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afdf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10afe2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10afe5: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10afea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10afed: 68 44 09 12 00 push $0x120944 <== NOT EXECUTED 10aff2: e8 15 10 00 00 call 10c00c <_Objects_Name_to_id_u32> <== NOT EXECUTED 10aff7: 8b 04 85 38 a7 11 00 mov 0x11a738(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10affe: c9 leave <== NOT EXECUTED 10afff: c3 ret <== NOT EXECUTED 00109760 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 109760: 55 push %ebp <== NOT EXECUTED 109761: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109763: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 109766: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109769: 6a 00 push $0x0 <== NOT EXECUTED 10976b: 6a 01 push $0x1 <== NOT EXECUTED 10976d: e8 b6 09 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 001062d0 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 1062d0: 55 push %ebp <== NOT EXECUTED 1062d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1062d3: 57 push %edi <== NOT EXECUTED 1062d4: 56 push %esi <== NOT EXECUTED 1062d5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1062d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 1062db: 85 f6 test %esi,%esi <== NOT EXECUTED 1062dd: 75 0d jne 1062ec <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 1062df: e8 cc 83 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 1062e4: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 1062ea: eb 13 jmp 1062ff <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 1062ec: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 1062ef: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 1062f2: 75 10 jne 106304 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1062f4: e8 b7 83 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 1062f9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1062ff: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 106302: eb 39 jmp 10633d <== NOT EXECUTED parent = *pathloc; 106304: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 106307: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10630c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 10630e: 52 push %edx <== NOT EXECUTED 10630f: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 106312: 56 push %esi <== NOT EXECUTED 106313: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106316: 68 45 67 11 00 push $0x116745 <== NOT EXECUTED 10631b: ff 10 call *(%eax) <== NOT EXECUTED 10631d: 89 c7 mov %eax,%edi <== NOT EXECUTED if (result != 0){ 10631f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106322: 85 c0 test %eax,%eax <== NOT EXECUTED 106324: 75 d9 jne 1062ff <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); 106326: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 106329: 85 c0 test %eax,%eax <== NOT EXECUTED 10632b: 74 10 je 10633d <== NOT EXECUTED 10632d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106330: 85 c0 test %eax,%eax <== NOT EXECUTED 106332: 74 09 je 10633d <== NOT EXECUTED 106334: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106337: 56 push %esi <== NOT EXECUTED 106338: ff d0 call *%eax <== NOT EXECUTED 10633a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 10633d: 89 f8 mov %edi,%eax <== NOT EXECUTED 10633f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106342: 5e pop %esi <== NOT EXECUTED 106343: 5f pop %edi <== NOT EXECUTED 106344: c9 leave <== NOT EXECUTED 106345: c3 ret <== NOT EXECUTED 00106346 : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 106346: 55 push %ebp <== NOT EXECUTED 106347: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106349: 57 push %edi <== NOT EXECUTED 10634a: 56 push %esi <== NOT EXECUTED 10634b: 53 push %ebx <== NOT EXECUTED 10634c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10634f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 106352: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106355: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 106358: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10635b: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 10635e: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 106361: 89 7d ec mov %edi,-0x14(%ebp) <== NOT EXECUTED /* * Verify Input parameters. */ if ( !pathname ) 106364: 85 db test %ebx,%ebx <== NOT EXECUTED 106366: 75 0d jne 106375 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 106368: e8 43 83 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10636d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 106373: eb 11 jmp 106386 <== NOT EXECUTED if ( !pathloc ) 106375: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 106379: 75 13 jne 10638e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 10637b: e8 30 83 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 106380: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 106386: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 106389: e9 cd 00 00 00 jmp 10645b <== NOT EXECUTED /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 10638e: 8a 03 mov (%ebx),%al <== NOT EXECUTED 106390: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 106392: 74 08 je 10639c <== NOT EXECUTED 106394: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 106396: 74 04 je 10639c <== NOT EXECUTED 106398: 84 c0 test %al,%al <== NOT EXECUTED 10639a: 75 16 jne 1063b2 <== NOT EXECUTED 10639c: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 1063a1: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 1063a4: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1063a9: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 1063ac: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1063ae: b1 01 mov $0x1,%cl <== NOT EXECUTED 1063b0: eb 12 jmp 1063c4 <== NOT EXECUTED 1063b2: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 1063b7: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 1063ba: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1063bf: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 1063c2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 1063c4: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 1063c7: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 1063ca: 8b 10 mov (%eax),%edx <== NOT EXECUTED 1063cc: 85 d2 test %edx,%edx <== NOT EXECUTED 1063ce: 74 66 je 106436 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 1063d0: 56 push %esi <== NOT EXECUTED 1063d1: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1063d4: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1063d7: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED 1063da: 50 push %eax <== NOT EXECUTED 1063db: ff d2 call *%edx <== NOT EXECUTED 1063dd: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Get the Node type and determine if you need to follow the link or * not. */ if ( (result == 0) && follow_link ) { 1063df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1063e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1063e4: 75 75 jne 10645b <== NOT EXECUTED 1063e6: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 1063ea: 74 6f je 10645b <== NOT EXECUTED if ( !pathloc->ops->node_type_h ){ 1063ec: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 1063ef: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 1063f2: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1063f5: 85 d2 test %edx,%edx <== NOT EXECUTED 1063f7: 75 0d jne 106406 <== NOT EXECUTED rtems_filesystem_freenode( pathloc ); 1063f9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1063fc: 85 c0 test %eax,%eax <== NOT EXECUTED 1063fe: 74 36 je 106436 <== NOT EXECUTED 106400: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106403: 57 push %edi <== NOT EXECUTED 106404: eb 2b jmp 106431 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 106406: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106409: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10640c: ff d2 call *%edx <== NOT EXECUTED if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 10640e: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 106411: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106414: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 106417: 77 42 ja 10645b <== NOT EXECUTED ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 106419: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10641c: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10641f: 8b 48 34 mov 0x34(%eax),%ecx <== NOT EXECUTED 106422: 85 c9 test %ecx,%ecx <== NOT EXECUTED 106424: 75 20 jne 106446 <== NOT EXECUTED rtems_filesystem_freenode( pathloc ); 106426: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106429: 85 c0 test %eax,%eax <== NOT EXECUTED 10642b: 74 09 je 106436 <== NOT EXECUTED 10642d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106430: 52 push %edx <== NOT EXECUTED 106431: ff d0 call *%eax <== NOT EXECUTED 106433: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106436: e8 75 82 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 10643b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106441: e9 40 ff ff ff jmp 106386 <== 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 ); 106446: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 106449: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10644c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10644f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } return result; } 106452: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106455: 5b pop %ebx <== NOT EXECUTED 106456: 5e pop %esi <== NOT EXECUTED 106457: 5f pop %edi <== NOT EXECUTED 106458: 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 ); 106459: ff e1 jmp *%ecx <== NOT EXECUTED } } return result; } 10645b: 89 f0 mov %esi,%eax <== NOT EXECUTED 10645d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106460: 5b pop %ebx <== NOT EXECUTED 106461: 5e pop %esi <== NOT EXECUTED 106462: 5f pop %edi <== NOT EXECUTED 106463: c9 leave <== NOT EXECUTED 106464: c3 ret <== NOT EXECUTED 0010cafc : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10cafc: 55 push %ebp <== NOT EXECUTED 10cafd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caff: 57 push %edi <== NOT EXECUTED 10cb00: 56 push %esi <== NOT EXECUTED 10cb01: 53 push %ebx <== NOT EXECUTED 10cb02: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10cb05: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10cb0a: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) <== NOT EXECUTED init_fs_mount_table(); 10cb11: e8 d2 04 00 00 call 10cfe8 <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10cb16: 83 3d 88 54 11 00 00 cmpl $0x0,0x115488 <== NOT EXECUTED 10cb1d: 75 0a jne 10cb29 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0001 ); 10cb1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb22: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10cb27: eb 2a jmp 10cb53 <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 10cb29: a1 e0 85 11 00 mov 0x1185e0,%eax <== NOT EXECUTED status = mount( 10cb2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb31: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10cb34: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10cb37: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10cb3a: ff 30 pushl (%eax) <== NOT EXECUTED 10cb3c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10cb3f: 50 push %eax <== NOT EXECUTED 10cb40: e8 c8 04 00 00 call 10d00d <== NOT EXECUTED &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10cb45: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10cb48: 40 inc %eax <== NOT EXECUTED 10cb49: 75 0d jne 10cb58 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0002 ); 10cb4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb4e: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10cb53: e8 08 cc ff ff call 109760 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 10cb58: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10cb5d: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) <== NOT EXECUTED * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 10cb63: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10cb66: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cb69: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10cb6c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cb71: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cb73: 6a 00 push $0x0 <== NOT EXECUTED 10cb75: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10cb78: 53 push %ebx <== NOT EXECUTED 10cb79: 6a 00 push $0x0 <== NOT EXECUTED 10cb7b: 68 e0 6b 11 00 push $0x116be0 <== NOT EXECUTED 10cb80: e8 c1 97 ff ff call 106346 <== NOT EXECUTED rtems_filesystem_root = loc; 10cb85: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10cb8a: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10cb8d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cb92: 89 de mov %ebx,%esi <== NOT EXECUTED 10cb94: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cb96: 6a 00 push $0x0 <== NOT EXECUTED 10cb98: 53 push %ebx <== NOT EXECUTED 10cb99: 6a 00 push $0x0 <== NOT EXECUTED 10cb9b: 68 e0 6b 11 00 push $0x116be0 <== NOT EXECUTED 10cba0: e8 a1 97 ff ff call 106346 <== NOT EXECUTED rtems_filesystem_current = loc; 10cba5: a1 6c a9 11 00 mov 0x11a96c,%eax <== NOT EXECUTED 10cbaa: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 10cbad: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cbb2: 89 de mov %ebx,%esi <== NOT EXECUTED 10cbb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 10cbb6: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10cbb9: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 10cbbe: 68 e2 6b 11 00 push $0x116be2 <== NOT EXECUTED 10cbc3: e8 04 04 00 00 call 10cfcc <== NOT EXECUTED if ( status != 0 ) 10cbc8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cbcb: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbcd: 74 0d je 10cbdc <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0003 ); 10cbcf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cbd2: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10cbd7: e9 77 ff ff ff jmp 10cb53 <== NOT EXECUTED * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10cbdc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cbdf: 5b pop %ebx <== NOT EXECUTED 10cbe0: 5e pop %esi <== NOT EXECUTED 10cbe1: 5f pop %edi <== NOT EXECUTED 10cbe2: c9 leave <== NOT EXECUTED 10cbe3: c3 ret <== NOT EXECUTED 001209b4 : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 1209b4: 55 push %ebp <== NOT EXECUTED 1209b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1209b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1209ba: 8b 10 mov (%eax),%edx <== NOT EXECUTED 1209bc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1209bf: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 1209c1: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 1209c4: c9 leave <== NOT EXECUTED 1209c5: c3 ret <== NOT EXECUTED 0010adb0 : #endif #include const char *rtems_get_version_string(void) { 10adb0: 55 push %ebp <== NOT EXECUTED 10adb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10adb3: b8 d8 bd 11 00 mov $0x11bdd8,%eax <== NOT EXECUTED 10adb8: c9 leave <== NOT EXECUTED 10adb9: c3 ret <== NOT EXECUTED 0010962c : * Scheduling can properly occur now as long as we avoid dispatching. */ } void rtems_initialize_before_drivers(void) { 10962c: 55 push %ebp <== NOT EXECUTED 10962d: 89 e5 mov %esp,%ebp <== NOT EXECUTED * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); } 10962f: c9 leave <== NOT EXECUTED /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 109630: e9 82 02 00 00 jmp 1098b7 <_API_extensions_Run_predriver> <== NOT EXECUTED 00109635 : Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ]; void rtems_initialize_data_structures( rtems_configuration_table *configuration_table ) { 109635: 55 push %ebp <== NOT EXECUTED 109636: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109638: 53 push %ebx <== NOT EXECUTED 109639: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10963c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Dispatching and interrupts are disabled until the end of the * initialization sequence. This prevents an inadvertent context * switch before the executive is initialized. */ _ISR_Disable( bsp_level ); 10963f: 9c pushf <== NOT EXECUTED 109640: fa cli <== NOT EXECUTED 109641: 58 pop %eax <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) 109642: 85 db test %ebx,%ebx <== NOT EXECUTED 109644: 75 0c jne 109652 <== NOT EXECUTED _Internal_error_Occurred( 109646: 50 push %eax <== NOT EXECUTED 109647: 6a 00 push $0x0 <== NOT EXECUTED 109649: 6a 01 push $0x1 <== NOT EXECUTED 10964b: 6a 00 push $0x0 <== NOT EXECUTED 10964d: e8 d6 0a 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 109652: 89 1d 98 ca 11 00 mov %ebx,0x11ca98 <== NOT EXECUTED /* * Initialize any target architecture specific support as early as possible */ _CPU_Initialize( _Thread_Dispatch ); 109658: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10965b: 68 7c ac 10 00 push $0x10ac7c <== NOT EXECUTED 109660: e8 4b 29 00 00 call 10bfb0 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 109665: c7 05 a0 cb 11 00 00 movl $0x0,0x11cba0 <== NOT EXECUTED 10966c: 00 00 00 <== NOT EXECUTED /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 10966f: e8 5c 3f 00 00 call 10d5d0 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 109674: e8 1b 02 00 00 call 109894 <_API_extensions_Initialization> <== NOT EXECUTED 109679: c7 05 00 ca 11 00 01 movl $0x1,0x11ca00 <== NOT EXECUTED 109680: 00 00 00 <== NOT EXECUTED /* * Before this is called, we are not allowed to allocate memory * from the Workspace because it is not initialized. */ _Workspace_Handler_initialization( 109683: 59 pop %ecx <== NOT EXECUTED 109684: 58 pop %eax <== NOT EXECUTED 109685: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 109688: ff 33 pushl (%ebx) <== NOT EXECUTED 10968a: e8 0b 27 00 00 call 10bd9a <_Workspace_Handler_initialization> <== NOT EXECUTED (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 10968f: 58 pop %eax <== NOT EXECUTED 109690: 5a pop %edx <== NOT EXECUTED 109691: ff 73 3c pushl 0x3c(%ebx) <== NOT EXECUTED 109694: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 109697: e8 b4 22 00 00 call 10b950 <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10969c: e8 c7 0a 00 00 call 10a168 <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 1096a1: e8 0e 11 00 00 call 10a7b4 <_Objects_Handler_initialization> <== NOT EXECUTED _Configuration_MP_table->maximum_nodes, _Configuration_MP_table->maximum_global_objects #endif ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 1096a6: c7 05 d8 c9 11 00 18 movl $0x11ca18,0x11c9d8 <== NOT EXECUTED 1096ad: ca 11 00 <== NOT EXECUTED /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 1096b0: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 1096b7: e8 14 03 00 00 call 1099d0 <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 1096bc: c7 04 24 b8 ca 11 00 movl $0x11cab8,(%esp) <== NOT EXECUTED 1096c3: e8 88 02 00 00 call 109950 <_API_Mutex_Allocate> <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 1096c8: 66 c7 05 b4 ca 11 00 movw $0x0,0x11cab4 <== NOT EXECUTED 1096cf: 00 00 <== NOT EXECUTED 1096d1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1096d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 1096d6: 66 c7 84 00 2c cb 11 movw $0x0,0x11cb2c(%eax,%eax,1) <== NOT EXECUTED 1096dd: 00 00 00 <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 1096e0: 40 inc %eax <== NOT EXECUTED 1096e1: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 1096e4: 75 f0 jne 1096d6 <== NOT EXECUTED _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 1096e6: e8 29 25 00 00 call 10bc14 <_Watchdog_Handler_initialization> <== NOT EXECUTED _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 1096eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1096ee: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1096f1: e8 ce 07 00 00 call 109ec4 <_TOD_Handler_initialization> <== NOT EXECUTED _Thread_Handler_initialization( 1096f6: 5a pop %edx <== NOT EXECUTED 1096f7: 59 pop %ecx <== NOT EXECUTED 1096f8: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1096fb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1096fe: e8 29 19 00 00 call 10b02c <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 109703: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109706: e8 05 01 00 00 call 109810 <_RTEMS_API_Initialize> <== NOT EXECUTED _Extension_Manager_initialization( configuration_table->maximum_extensions ); 10970b: 58 pop %eax <== NOT EXECUTED 10970c: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10970f: e8 28 00 00 00 call 10973c <_Extension_Manager_initialization> <== NOT EXECUTED _IO_Manager_initialization( 109714: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109717: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10971a: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10971d: ff 73 34 pushl 0x34(%ebx) <== NOT EXECUTED 109720: e8 76 00 00 00 call 10979b <_IO_Manager_initialization> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 109725: c7 05 a0 cb 11 00 01 movl $0x1,0x11cba0 <== NOT EXECUTED 10972c: 00 00 00 <== NOT EXECUTED * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 10972f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 109732: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109735: c9 leave <== NOT EXECUTED * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 109736: e9 6d 14 00 00 jmp 10aba8 <_Thread_Create_idle> <== NOT EXECUTED 0010961b : _API_extensions_Run_predriver(); } void rtems_initialize_device_drivers(void) { 10961b: 55 push %ebp <== NOT EXECUTED 10961c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10961e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 109621: e8 4e 01 00 00 call 109774 <_IO_Initialize_all_drivers> <== NOT EXECUTED * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); } 109626: c9 leave <== NOT EXECUTED * Run the APIs and BSPs postdriver hooks. * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); 109627: e9 b1 02 00 00 jmp 1098dd <_API_extensions_Run_postdriver> <== NOT EXECUTED 00109608 : _API_extensions_Run_postdriver(); } void rtems_initialize_start_multitasking(void) { 109608: 55 push %ebp <== NOT EXECUTED 109609: 89 e5 mov %esp,%ebp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10960b: c7 05 a0 cb 11 00 02 movl $0x2,0x11cba0 <== NOT EXECUTED 109612: 00 00 00 <== NOT EXECUTED ****** APPLICATION RUNS HERE ****** ****** RETURNS WHEN SYSTEM IS SHUT DOWN ****** ******************************************************************* ******************************************************************* *******************************************************************/ } 109615: c9 leave <== NOT EXECUTED void rtems_initialize_start_multitasking(void) { _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING ); _Thread_Start_multitasking(); 109616: e9 55 21 00 00 jmp 10b770 <_Thread_Start_multitasking> <== NOT EXECUTED 001094a4 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 1094a4: 55 push %ebp <== NOT EXECUTED 1094a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1094a7: 53 push %ebx <== NOT EXECUTED 1094a8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1094ab: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1094ae: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1094b1: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 1094b4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1094b9: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED 1094bf: 77 1d ja 1094de <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 1094c1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1094c3: 74 14 je 1094d9 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 1094c5: 85 d2 test %edx,%edx <== NOT EXECUTED 1094c7: 74 10 je 1094d9 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 1094c9: 50 push %eax <== NOT EXECUTED 1094ca: 52 push %edx <== NOT EXECUTED 1094cb: 51 push %ecx <== NOT EXECUTED 1094cc: 53 push %ebx <== NOT EXECUTED 1094cd: e8 60 cc ff ff call 106132 <_CPU_ISR_install_vector> <== NOT EXECUTED 1094d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 1094d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094d7: eb 05 jmp 1094de <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 1094d9: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 1094de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1094e1: c9 leave <== NOT EXECUTED 1094e2: c3 ret <== NOT EXECUTED 001099c0 : */ #undef rtems_interrupt_disable rtems_interrupt_level rtems_interrupt_disable( void ) { 1099c0: 55 push %ebp <== NOT EXECUTED 1099c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); 1099c3: 9c pushf <== NOT EXECUTED 1099c4: fa cli <== NOT EXECUTED 1099c5: 58 pop %eax <== NOT EXECUTED return previous_level; } 1099c6: c9 leave <== NOT EXECUTED 1099c7: c3 ret <== NOT EXECUTED 001099c8 : #undef rtems_interrupt_enable void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { 1099c8: 55 push %ebp <== NOT EXECUTED 1099c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Enable( previous_level ); 1099cb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099ce: 9d popf <== NOT EXECUTED } 1099cf: c9 leave <== NOT EXECUTED 1099d0: c3 ret <== NOT EXECUTED 001099d1 : #undef rtems_interrupt_flash void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { 1099d1: 55 push %ebp <== NOT EXECUTED 1099d2: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Flash( previous_level ); 1099d4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099d7: 9d popf <== NOT EXECUTED 1099d8: fa cli <== NOT EXECUTED } 1099d9: c9 leave <== NOT EXECUTED 1099da: c3 ret <== NOT EXECUTED 001099db : */ #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { 1099db: 55 push %ebp <== NOT EXECUTED 1099dc: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _ISR_Is_in_progress(); 1099de: a1 50 f5 11 00 mov 0x11f550,%eax <== NOT EXECUTED 1099e3: 85 c0 test %eax,%eax <== NOT EXECUTED 1099e5: 0f 95 c0 setne %al <== NOT EXECUTED } 1099e8: c9 leave <== NOT EXECUTED 1099e9: c3 ret <== NOT EXECUTED 0010e3a8 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e3a8: 55 push %ebp <== NOT EXECUTED 10e3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3ab: 56 push %esi <== NOT EXECUTED 10e3ac: 53 push %ebx <== NOT EXECUTED 10e3ad: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e3b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e3b3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e3b6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e3bb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e3c1: 73 20 jae 10e3e3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 10e3c3: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e3c6: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e3cb: 8b 54 02 08 mov 0x8(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e3cf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e3d1: 85 d2 test %edx,%edx <== NOT EXECUTED 10e3d3: 74 0e je 10e3e3 <== NOT EXECUTED 10e3d5: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e3d8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e3db: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e3de: 5b pop %ebx <== NOT EXECUTED 10e3df: 5e pop %esi <== NOT EXECUTED 10e3e0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e3e1: ff e2 jmp *%edx <== NOT EXECUTED } 10e3e3: 5b pop %ebx <== NOT EXECUTED 10e3e4: 5e pop %esi <== NOT EXECUTED 10e3e5: c9 leave <== NOT EXECUTED 10e3e6: c3 ret <== NOT EXECUTED 0010e3e8 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e3e8: 55 push %ebp <== NOT EXECUTED 10e3e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3eb: 56 push %esi <== NOT EXECUTED 10e3ec: 53 push %ebx <== NOT EXECUTED 10e3ed: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e3f0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e3f3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e3f6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e3fb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e401: 73 20 jae 10e423 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 10e403: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e406: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e40b: 8b 54 02 14 mov 0x14(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e40f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e411: 85 d2 test %edx,%edx <== NOT EXECUTED 10e413: 74 0e je 10e423 <== NOT EXECUTED 10e415: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e418: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e41b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e41e: 5b pop %ebx <== NOT EXECUTED 10e41f: 5e pop %esi <== NOT EXECUTED 10e420: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e421: ff e2 jmp *%edx <== NOT EXECUTED } 10e423: 5b pop %ebx <== NOT EXECUTED 10e424: 5e pop %esi <== NOT EXECUTED 10e425: c9 leave <== NOT EXECUTED 10e426: c3 ret <== NOT EXECUTED 0010d610 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10d610: 55 push %ebp <== NOT EXECUTED 10d611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d613: 56 push %esi <== NOT EXECUTED 10d614: 53 push %ebx <== NOT EXECUTED 10d615: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d618: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d61b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10d61e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10d623: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10d629: 73 1f jae 10d64a <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10d62b: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10d62e: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10d633: 8b 14 02 mov (%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10d636: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d638: 85 d2 test %edx,%edx <== NOT EXECUTED 10d63a: 74 0e je 10d64a <== NOT EXECUTED 10d63c: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10d63f: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10d642: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10d645: 5b pop %ebx <== NOT EXECUTED 10d646: 5e pop %esi <== NOT EXECUTED 10d647: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10d648: ff e2 jmp *%edx <== NOT EXECUTED } 10d64a: 5b pop %ebx <== NOT EXECUTED 10d64b: 5e pop %esi <== NOT EXECUTED 10d64c: c9 leave <== NOT EXECUTED 10d64d: c3 ret <== NOT EXECUTED 00106178 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 106178: 55 push %ebp <== NOT EXECUTED 106179: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10617b: 57 push %edi <== NOT EXECUTED 10617c: 56 push %esi <== NOT EXECUTED 10617d: 53 push %ebx <== NOT EXECUTED 10617e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 106181: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106184: 8b 75 0c mov 0xc(%ebp),%esi <== 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 ); 106187: 6a 01 push $0x1 <== NOT EXECUTED 106189: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10618c: 50 push %eax <== NOT EXECUTED 10618d: 6a 00 push $0x0 <== NOT EXECUTED 10618f: 57 push %edi <== NOT EXECUTED 106190: e8 b1 01 00 00 call 106346 <== NOT EXECUTED 106195: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_jnode = loc.node_access; 106197: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10619a: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED if ( !loc.ops->node_type_h ) { 10619d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1061a0: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1061a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1061a6: 85 d2 test %edx,%edx <== NOT EXECUTED 1061a8: 75 23 jne 1061cd <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1061aa: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1061ad: 85 c0 test %eax,%eax <== NOT EXECUTED 1061af: 74 0c je 1061bd <== NOT EXECUTED 1061b1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1061b4: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 1061b7: 52 push %edx <== NOT EXECUTED 1061b8: ff d0 call *%eax <== NOT EXECUTED 1061ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1061bd: e8 ee 84 00 00 call 10e6b0 <__errno> <== NOT EXECUTED 1061c2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1061c8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1061cb: eb 78 jmp 106245 <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); 1061cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1061d0: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1061d3: 50 push %eax <== NOT EXECUTED 1061d4: ff d2 call *%edx <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 1061d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1061d9: 85 db test %ebx,%ebx <== NOT EXECUTED 1061db: 75 05 jne 1061e2 <== NOT EXECUTED 1061dd: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1061e0: 74 1e je 106200 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1061e2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1061e5: 85 c0 test %eax,%eax <== NOT EXECUTED 1061e7: 74 53 je 10623c <== NOT EXECUTED 1061e9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1061ec: 85 d2 test %edx,%edx <== NOT EXECUTED 1061ee: 74 4c je 10623c <== NOT EXECUTED 1061f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1061f3: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1061f6: 50 push %eax <== NOT EXECUTED 1061f7: ff d2 call *%edx <== NOT EXECUTED 1061f9: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 1061fe: eb 37 jmp 106237 <== NOT EXECUTED return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 106200: 89 3e mov %edi,(%esi) <== NOT EXECUTED device_info->device_name_length = strlen( name ); 106202: 31 c0 xor %eax,%eax <== NOT EXECUTED 106204: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 106207: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106209: f7 d1 not %ecx <== NOT EXECUTED 10620b: 49 dec %ecx <== NOT EXECUTED 10620c: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 10620f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106212: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED 106215: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 106218: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED 10621b: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10621e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106221: 85 c0 test %eax,%eax <== NOT EXECUTED 106223: 74 1e je 106243 <== NOT EXECUTED 106225: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106228: 85 c0 test %eax,%eax <== NOT EXECUTED 10622a: 74 17 je 106243 <== NOT EXECUTED 10622c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10622f: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 106232: 52 push %edx <== NOT EXECUTED 106233: ff d0 call *%eax <== NOT EXECUTED 106235: 31 c0 xor %eax,%eax <== NOT EXECUTED 106237: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10623a: eb 09 jmp 106245 <== NOT EXECUTED 10623c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106241: eb 02 jmp 106245 <== NOT EXECUTED 106243: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 106245: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106248: 5b pop %ebx <== NOT EXECUTED 106249: 5e pop %esi <== NOT EXECUTED 10624a: 5f pop %edi <== NOT EXECUTED 10624b: c9 leave <== NOT EXECUTED 10624c: c3 ret <== NOT EXECUTED 0010e428 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e428: 55 push %ebp <== NOT EXECUTED 10e429: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e42b: 56 push %esi <== NOT EXECUTED 10e42c: 53 push %ebx <== NOT EXECUTED 10e42d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e430: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e433: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e436: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e43b: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e441: 73 20 jae 10e463 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 10e443: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e446: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e44b: 8b 54 02 04 mov 0x4(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e44f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e451: 85 d2 test %edx,%edx <== NOT EXECUTED 10e453: 74 0e je 10e463 <== NOT EXECUTED 10e455: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e458: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e45b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e45e: 5b pop %ebx <== NOT EXECUTED 10e45f: 5e pop %esi <== NOT EXECUTED 10e460: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e461: ff e2 jmp *%edx <== NOT EXECUTED } 10e463: 5b pop %ebx <== NOT EXECUTED 10e464: 5e pop %esi <== NOT EXECUTED 10e465: c9 leave <== NOT EXECUTED 10e466: c3 ret <== NOT EXECUTED 0010e468 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e468: 55 push %ebp <== NOT EXECUTED 10e469: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e46b: 56 push %esi <== NOT EXECUTED 10e46c: 53 push %ebx <== NOT EXECUTED 10e46d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e470: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e473: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e476: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e47b: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e481: 73 20 jae 10e4a3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 10e483: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e486: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e48b: 8b 54 02 0c mov 0xc(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e48f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e491: 85 d2 test %edx,%edx <== NOT EXECUTED 10e493: 74 0e je 10e4a3 <== NOT EXECUTED 10e495: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e498: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e49b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e49e: 5b pop %ebx <== NOT EXECUTED 10e49f: 5e pop %esi <== NOT EXECUTED 10e4a0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4a1: ff e2 jmp *%edx <== NOT EXECUTED } 10e4a3: 5b pop %ebx <== NOT EXECUTED 10e4a4: 5e pop %esi <== NOT EXECUTED 10e4a5: c9 leave <== NOT EXECUTED 10e4a6: c3 ret <== NOT EXECUTED 0010a4d8 : 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 ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 57 push %edi <== NOT EXECUTED 10a4dc: 56 push %esi <== NOT EXECUTED 10a4dd: 53 push %ebx <== NOT EXECUTED 10a4de: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a4e1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4e4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a4e7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a4ea: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10a4ed: 85 f6 test %esi,%esi <== NOT EXECUTED 10a4ef: 0f 84 9a 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10a4f5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4f7: 0f 84 92 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10a4fd: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 10a500: 75 0a jne 10a50c <== NOT EXECUTED 10a502: 83 7e 04 00 cmpl $0x0,0x4(%esi) <== NOT EXECUTED 10a506: 0f 84 83 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10a50c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a50f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10a515: 8b 15 58 f7 11 00 mov 0x11f758,%edx <== NOT EXECUTED 10a51b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a520: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10a522: 73 77 jae 10a59b <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10a524: 85 db test %ebx,%ebx <== NOT EXECUTED 10a526: 75 2b jne 10a553 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a528: 8d 5a ff lea -0x1(%edx),%ebx <== NOT EXECUTED 10a52b: 6b c2 18 imul $0x18,%edx,%eax <== NOT EXECUTED 10a52e: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a531: 03 05 5c f7 11 00 add 0x11f75c,%eax <== NOT EXECUTED 10a537: eb 0f jmp 10a548 <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10a539: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a53c: 75 06 jne 10a544 <== NOT EXECUTED 10a53e: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 10a542: 74 0f je 10a553 <== NOT EXECUTED * in use. */ if ( major == 0 ) { bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a544: 4b dec %ebx <== NOT EXECUTED 10a545: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a548: 85 db test %ebx,%ebx <== NOT EXECUTED 10a54a: 75 ed jne 10a539 <== NOT EXECUTED 10a54c: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a551: eb 48 jmp 10a59b <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10a553: 6b fb 18 imul $0x18,%ebx,%edi <== NOT EXECUTED 10a556: 03 3d 5c f7 11 00 add 0x11f75c,%edi <== NOT EXECUTED 10a55c: 83 3f 00 cmpl $0x0,(%edi) <== NOT EXECUTED 10a55f: 75 35 jne 10a596 <== NOT EXECUTED 10a561: 83 7f 04 00 cmpl $0x0,0x4(%edi) <== NOT EXECUTED 10a565: 75 2f jne 10a596 <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10a567: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a56c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10a56e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a571: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10a573: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10a57a: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10a581: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10a584: 5b pop %ebx <== NOT EXECUTED 10a585: 5e pop %esi <== NOT EXECUTED 10a586: 5b pop %ebx <== NOT EXECUTED 10a587: 5e pop %esi <== NOT EXECUTED 10a588: 5f pop %edi <== NOT EXECUTED 10a589: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10a58a: e9 ed fd ff ff jmp 10a37c <== NOT EXECUTED 10a58f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a594: eb 05 jmp 10a59b <== NOT EXECUTED 10a596: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10a59b: 5a pop %edx <== NOT EXECUTED 10a59c: 59 pop %ecx <== NOT EXECUTED 10a59d: 5b pop %ebx <== NOT EXECUTED 10a59e: 5e pop %esi <== NOT EXECUTED 10a59f: 5f pop %edi <== NOT EXECUTED 10a5a0: c9 leave <== NOT EXECUTED 10a5a1: c3 ret <== NOT EXECUTED 0010624d : rtems_status_code rtems_io_register_name( const char *device_name, rtems_device_major_number major, rtems_device_minor_number minor ) { 10624d: 55 push %ebp <== NOT EXECUTED 10624e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106250: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106253: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106256: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED #if !defined(RTEMS_UNIX) int status; dev_t dev; dev = rtems_filesystem_make_dev_t( major, minor ); status = mknod( device_name, 0777 | S_IFCHR, dev ); 106259: 52 push %edx <== NOT EXECUTED 10625a: 50 push %eax <== NOT EXECUTED 10625b: 68 ff 21 00 00 push $0x21ff <== NOT EXECUTED 106260: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106263: e8 94 04 00 00 call 1066fc <== NOT EXECUTED /* this is the only error returned by the old version */ if ( status ) 106268: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10626b: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10626e: 19 c0 sbb %eax,%eax <== NOT EXECUTED 106270: f7 d0 not %eax <== NOT EXECUTED 106272: 83 e0 05 and $0x5,%eax <== NOT EXECUTED return RTEMS_TOO_MANY; #endif return RTEMS_SUCCESSFUL; } 106275: c9 leave <== NOT EXECUTED 106276: c3 ret <== NOT EXECUTED 0010a5a4 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10a5a4: 55 push %ebp <== NOT EXECUTED 10a5a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5a7: 57 push %edi <== NOT EXECUTED 10a5a8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a5ab: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10a5ae: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10a5b3: 3b 15 58 f7 11 00 cmp 0x11f758,%edx <== NOT EXECUTED 10a5b9: 73 12 jae 10a5cd <== NOT EXECUTED memset( 10a5bb: 6b fa 18 imul $0x18,%edx,%edi <== NOT EXECUTED 10a5be: 03 3d 5c f7 11 00 add 0x11f75c,%edi <== NOT EXECUTED 10a5c4: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a5c9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a5cb: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10a5cd: 5a pop %edx <== NOT EXECUTED 10a5ce: 5f pop %edi <== NOT EXECUTED 10a5cf: c9 leave <== NOT EXECUTED 10a5d0: c3 ret <== NOT EXECUTED 0010e4a8 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e4a8: 55 push %ebp <== NOT EXECUTED 10e4a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e4ab: 56 push %esi <== NOT EXECUTED 10e4ac: 53 push %ebx <== NOT EXECUTED 10e4ad: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e4b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e4b3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e4b6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e4bb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e4c1: 73 20 jae 10e4e3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 10e4c3: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e4c6: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e4cb: 8b 54 02 10 mov 0x10(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4cf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e4d1: 85 d2 test %edx,%edx <== NOT EXECUTED 10e4d3: 74 0e je 10e4e3 <== NOT EXECUTED 10e4d5: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e4d8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e4db: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e4de: 5b pop %ebx <== NOT EXECUTED 10e4df: 5e pop %esi <== NOT EXECUTED 10e4e0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4e1: ff e2 jmp *%edx <== NOT EXECUTED } 10e4e3: 5b pop %ebx <== NOT EXECUTED 10e4e4: 5e pop %esi <== NOT EXECUTED 10e4e5: c9 leave <== NOT EXECUTED 10e4e6: c3 ret <== NOT EXECUTED 0010b40c : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10b40c: 55 push %ebp <== NOT EXECUTED 10b40d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b40f: 57 push %edi <== NOT EXECUTED 10b410: 56 push %esi <== NOT EXECUTED 10b411: 53 push %ebx <== NOT EXECUTED 10b412: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10b415: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10b419: 74 41 je 10b45c <== NOT EXECUTED return; 10b41b: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 10b420: 8b 04 bd 90 83 12 00 mov 0x128390(,%edi,4),%eax <== NOT EXECUTED 10b427: 85 c0 test %eax,%eax <== NOT EXECUTED 10b429: 74 2b je 10b456 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10b42b: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10b42e: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10b433: 85 f6 test %esi,%esi <== NOT EXECUTED 10b435: 75 17 jne 10b44e <== NOT EXECUTED 10b437: eb 1d jmp 10b456 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10b439: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10b43c: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10b43f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b441: 74 0a je 10b44d <== NOT EXECUTED continue; (*routine)(the_thread); 10b443: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b446: 50 push %eax <== NOT EXECUTED 10b447: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10b44a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 10b44d: 43 inc %ebx <== NOT EXECUTED 10b44e: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10b452: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b454: 76 e3 jbe 10b439 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10b456: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10b457: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10b45a: 75 c4 jne 10b420 <== NOT EXECUTED (*routine)(the_thread); } } } } 10b45c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b45f: 5b pop %ebx <== NOT EXECUTED 10b460: 5e pop %esi <== NOT EXECUTED 10b461: 5f pop %edi <== NOT EXECUTED 10b462: c9 leave <== NOT EXECUTED 10b463: c3 ret <== NOT EXECUTED 0010cf05 : * 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 ) { 10cf05: 55 push %ebp <== NOT EXECUTED 10cf06: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf08: 57 push %edi <== NOT EXECUTED 10cf09: 53 push %ebx <== NOT EXECUTED 10cf0a: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED rtems_libio_t *iop, *next; rtems_status_code rc; rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10cf0d: 6a 00 push $0x0 <== NOT EXECUTED 10cf0f: 6a 00 push $0x0 <== NOT EXECUTED 10cf11: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10cf17: e8 2c c2 ff ff call 109148 <== NOT EXECUTED if (rtems_libio_iop_freelist) { 10cf1c: 8b 15 a4 c8 11 00 mov 0x11c8a4,%edx <== NOT EXECUTED 10cf22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf25: 85 d2 test %edx,%edx <== NOT EXECUTED 10cf27: 74 55 je 10cf7e <== NOT EXECUTED rc = rtems_semaphore_create( 10cf29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf2c: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10cf2f: 50 push %eax <== NOT EXECUTED 10cf30: 6a 00 push $0x0 <== NOT EXECUTED 10cf32: 6a 54 push $0x54 <== NOT EXECUTED 10cf34: 6a 01 push $0x1 <== NOT EXECUTED 10cf36: 2b 15 a0 c8 11 00 sub 0x11c8a0,%edx <== NOT EXECUTED 10cf3c: c1 fa 02 sar $0x2,%edx <== NOT EXECUTED 10cf3f: 69 c2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%eax <== NOT EXECUTED 10cf45: 0d 00 49 42 4c or $0x4c424900,%eax <== NOT EXECUTED 10cf4a: 50 push %eax <== NOT EXECUTED 10cf4b: e8 c4 bf ff ff call 108f14 <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10cf50: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10cf53: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf55: 75 27 jne 10cf7e <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 10cf57: 8b 1d a4 c8 11 00 mov 0x11c8a4,%ebx <== NOT EXECUTED next = iop->data1; 10cf5d: 8b 53 28 mov 0x28(%ebx),%edx <== NOT EXECUTED (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10cf60: b9 0d 00 00 00 mov $0xd,%ecx <== NOT EXECUTED 10cf65: 89 df mov %ebx,%edi <== NOT EXECUTED 10cf67: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED iop->flags = LIBIO_FLAGS_OPEN; 10cf69: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) <== NOT EXECUTED iop->sem = sema; 10cf70: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10cf73: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = next; 10cf76: 89 15 a4 c8 11 00 mov %edx,0x11c8a4 <== NOT EXECUTED 10cf7c: eb 02 jmp 10cf80 <== NOT EXECUTED } failed: iop = 0; done: 10cf7e: 31 db xor %ebx,%ebx <== NOT EXECUTED rtems_semaphore_release( rtems_libio_semaphore ); 10cf80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf83: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10cf89: e8 a2 c2 ff ff call 109230 <== NOT EXECUTED return iop; } 10cf8e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cf90: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cf93: 5b pop %ebx <== NOT EXECUTED 10cf94: 5f pop %edi <== NOT EXECUTED 10cf95: c9 leave <== NOT EXECUTED 10cf96: c3 ret <== NOT EXECUTED 0010cf97 : }; uint32_t rtems_libio_fcntl_flags( uint32_t fcntl_flags ) { 10cf97: 55 push %ebp <== NOT EXECUTED 10cf98: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf9a: 56 push %esi <== NOT EXECUTED 10cf9b: 53 push %ebx <== NOT EXECUTED 10cf9c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * Access mode is a small integer */ access_modes = fcntl_flags & O_ACCMODE; fcntl_flags &= ~O_ACCMODE; flags = rtems_assoc_local_by_remote( access_modes_assoc, access_modes ); 10cf9f: 51 push %ecx <== NOT EXECUTED 10cfa0: 51 push %ecx <== NOT EXECUTED 10cfa1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cfa3: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10cfa6: 50 push %eax <== NOT EXECUTED 10cfa7: 68 10 6c 11 00 push $0x116c10 <== NOT EXECUTED 10cfac: e8 3f 12 00 00 call 10e1f0 <== NOT EXECUTED 10cfb1: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Everything else is single bits */ flags |= 10cfb3: 58 pop %eax <== NOT EXECUTED 10cfb4: 5a pop %edx <== NOT EXECUTED 10cfb5: 83 e3 fc and $0xfffffffc,%ebx <== NOT EXECUTED 10cfb8: 53 push %ebx <== NOT EXECUTED 10cfb9: 68 40 6c 11 00 push $0x116c40 <== NOT EXECUTED 10cfbe: e8 f1 11 00 00 call 10e1b4 <== NOT EXECUTED 10cfc3: 09 f0 or %esi,%eax <== NOT EXECUTED rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags); return flags; } 10cfc5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cfc8: 5b pop %ebx <== NOT EXECUTED 10cfc9: 5e pop %esi <== NOT EXECUTED 10cfca: c9 leave <== NOT EXECUTED 10cfcb: c3 ret <== NOT EXECUTED 0010ceb0 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10ceb0: 55 push %ebp <== NOT EXECUTED 10ceb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ceb3: 53 push %ebx <== NOT EXECUTED 10ceb4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ceb7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10ceba: 6a 00 push $0x0 <== NOT EXECUTED 10cebc: 6a 00 push $0x0 <== NOT EXECUTED 10cebe: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10cec4: e8 7f c2 ff ff call 109148 <== NOT EXECUTED if (iop->sem) 10cec9: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10cecc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cecf: 85 c0 test %eax,%eax <== NOT EXECUTED 10ced1: 74 0c je 10cedf <== NOT EXECUTED rtems_semaphore_delete(iop->sem); 10ced3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ced6: 50 push %eax <== NOT EXECUTED 10ced7: e8 dc c1 ff ff call 1090b8 <== NOT EXECUTED 10cedc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10cedf: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) <== NOT EXECUTED iop->data1 = rtems_libio_iop_freelist; 10cee6: a1 a4 c8 11 00 mov 0x11c8a4,%eax <== NOT EXECUTED 10ceeb: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = iop; 10ceee: 89 1d a4 c8 11 00 mov %ebx,0x11c8a4 <== NOT EXECUTED rtems_semaphore_release(rtems_libio_semaphore); 10cef4: a1 a8 c8 11 00 mov 0x11c8a8,%eax <== NOT EXECUTED 10cef9: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cefc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ceff: c9 leave <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_semaphore_release(rtems_libio_semaphore); 10cf00: e9 2b c3 ff ff jmp 109230 <== NOT EXECUTED 001064e0 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 1064e0: 55 push %ebp <== NOT EXECUTED 1064e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1064e3: 53 push %ebx <== NOT EXECUTED 1064e4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 1064e7: a1 d8 85 11 00 mov 0x1185d8,%eax <== NOT EXECUTED 1064ec: 85 c0 test %eax,%eax <== NOT EXECUTED 1064ee: 74 46 je 106536 <== NOT EXECUTED { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 1064f0: 52 push %edx <== NOT EXECUTED 1064f1: 52 push %edx <== NOT EXECUTED 1064f2: 6a 34 push $0x34 <== NOT EXECUTED 1064f4: 50 push %eax <== NOT EXECUTED 1064f5: e8 ea 66 00 00 call 10cbe4 <== NOT EXECUTED 1064fa: 89 c1 mov %eax,%ecx <== NOT EXECUTED 1064fc: a3 a0 c8 11 00 mov %eax,0x11c8a0 <== NOT EXECUTED sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 106501: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106504: 85 c0 test %eax,%eax <== NOT EXECUTED 106506: 75 07 jne 10650f <== NOT EXECUTED rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 106508: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10650b: 6a 1a push $0x1a <== NOT EXECUTED 10650d: eb 4a jmp 106559 <== NOT EXECUTED iop = rtems_libio_iop_freelist = rtems_libio_iops; 10650f: a3 a4 c8 11 00 mov %eax,0x11c8a4 <== NOT EXECUTED for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 106514: 8b 1d d8 85 11 00 mov 0x1185d8,%ebx <== NOT EXECUTED 10651a: 89 c2 mov %eax,%edx <== NOT EXECUTED 10651c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10651e: eb 03 jmp 106523 <== NOT EXECUTED iop->data1 = iop + 1; 106520: 89 52 f4 mov %edx,-0xc(%edx) <== NOT EXECUTED 106523: 40 inc %eax <== NOT EXECUTED 106524: 83 c2 34 add $0x34,%edx <== NOT EXECUTED sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 106527: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 106529: 75 f5 jne 106520 <== NOT EXECUTED iop->data1 = iop + 1; iop->data1 = NULL; 10652b: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 10652e: c7 44 01 f4 00 00 00 movl $0x0,-0xc(%ecx,%eax,1) <== NOT EXECUTED 106535: 00 <== NOT EXECUTED /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 106536: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106539: 68 a8 c8 11 00 push $0x11c8a8 <== NOT EXECUTED 10653e: 6a 00 push $0x0 <== NOT EXECUTED 106540: 6a 54 push $0x54 <== NOT EXECUTED 106542: 6a 01 push $0x1 <== NOT EXECUTED 106544: 68 4f 49 42 4c push $0x4c42494f <== NOT EXECUTED 106549: e8 c6 29 00 00 call 108f14 <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 10654e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 106551: 85 c0 test %eax,%eax <== NOT EXECUTED 106553: 74 09 je 10655e <== NOT EXECUTED rtems_fatal_error_occurred( rc ); 106555: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106558: 50 push %eax <== NOT EXECUTED 106559: e8 02 32 00 00 call 109760 <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); } 10655e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106561: c9 leave <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 106562: e9 95 65 00 00 jmp 10cafc <== NOT EXECUTED 0010cdf8 : */ int rtems_libio_is_file_open( void *node_access ) { 10cdf8: 55 push %ebp <== NOT EXECUTED 10cdf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdfb: 53 push %ebx <== NOT EXECUTED 10cdfc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cdff: 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 ); 10ce02: 6a 00 push $0x0 <== NOT EXECUTED 10ce04: 6a 00 push $0x0 <== NOT EXECUTED 10ce06: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10ce0c: e8 37 c3 ff ff call 109148 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ce11: a1 a0 c8 11 00 mov 0x11c8a0,%eax <== NOT EXECUTED 10ce16: 8b 0d d8 85 11 00 mov 0x1185d8,%ecx <== NOT EXECUTED 10ce1c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ce1e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce21: eb 16 jmp 10ce39 <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ce23: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 10ce27: 74 0c je 10ce35 <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10ce29: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 10ce2c: 75 07 jne 10ce35 <== NOT EXECUTED 10ce2e: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10ce33: eb 0a jmp 10ce3f <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ce35: 83 c0 34 add $0x34,%eax <== NOT EXECUTED 10ce38: 42 inc %edx <== NOT EXECUTED 10ce39: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10ce3b: 72 e6 jb 10ce23 <== NOT EXECUTED 10ce3d: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10ce3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce42: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10ce48: e8 e3 c3 ff ff call 109230 <== NOT EXECUTED return result; } 10ce4d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ce4f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce52: c9 leave <== NOT EXECUTED 10ce53: c3 ret <== NOT EXECUTED 0010ce54 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10ce54: 55 push %ebp <== NOT EXECUTED 10ce55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce57: 53 push %ebx <== NOT EXECUTED 10ce58: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ce5b: 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 ); 10ce5e: 6a 00 push $0x0 <== NOT EXECUTED 10ce60: 6a 00 push $0x0 <== NOT EXECUTED 10ce62: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10ce68: e8 db c2 ff ff call 109148 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ce6d: a1 a0 c8 11 00 mov 0x11c8a0,%eax <== NOT EXECUTED 10ce72: 8b 0d d8 85 11 00 mov 0x1185d8,%ecx <== NOT EXECUTED 10ce78: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ce7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce7d: eb 16 jmp 10ce95 <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ce7f: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 10ce83: 74 0c je 10ce91 <== 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 ) { 10ce85: 39 58 1c cmp %ebx,0x1c(%eax) <== NOT EXECUTED 10ce88: 75 07 jne 10ce91 <== NOT EXECUTED 10ce8a: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10ce8f: eb 0a jmp 10ce9b <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ce91: 83 c0 34 add $0x34,%eax <== NOT EXECUTED 10ce94: 42 inc %edx <== NOT EXECUTED 10ce95: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10ce97: 72 e6 jb 10ce7f <== NOT EXECUTED 10ce99: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10ce9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce9e: ff 35 a8 c8 11 00 pushl 0x11c8a8 <== NOT EXECUTED 10cea4: e8 87 c3 ff ff call 109230 <== NOT EXECUTED return result; } 10cea9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ceab: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ceae: c9 leave <== NOT EXECUTED 10ceaf: c3 ret <== NOT EXECUTED 00120419 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 120419: 55 push %ebp <== NOT EXECUTED 12041a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12041c: 57 push %edi <== NOT EXECUTED 12041d: 56 push %esi <== NOT EXECUTED 12041e: 53 push %ebx <== NOT EXECUTED 12041f: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_status_code sc; rtems_id task_id; rtems_filesystem_location_info_t loc; sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 120422: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 120425: 50 push %eax <== NOT EXECUTED 120426: 6a 00 push $0x0 <== NOT EXECUTED 120428: 6a 00 push $0x0 <== NOT EXECUTED 12042a: e8 dd 0c 00 00 call 12110c <== NOT EXECUTED 12042f: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 120431: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120434: 85 c0 test %eax,%eax <== NOT EXECUTED 120436: 0f 85 d4 00 00 00 jne 120510 <== NOT EXECUTED /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 12043c: 81 3d 84 3b 14 00 84 cmpl $0x159f84,0x143b84 <== NOT EXECUTED 120443: 9f 15 00 <== NOT EXECUTED 120446: 75 4e jne 120496 <== NOT EXECUTED rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 120448: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12044b: 6a 40 push $0x40 <== NOT EXECUTED 12044d: e8 8a a0 fe ff call 10a4dc <== NOT EXECUTED 120452: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!tmp) 120454: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120457: 85 c0 test %eax,%eax <== NOT EXECUTED 120459: 75 07 jne 120462 <== NOT EXECUTED 12045b: b3 1a mov $0x1a,%bl <== NOT EXECUTED 12045d: e9 ae 00 00 00 jmp 120510 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT tmp->refcnt = 1; #endif sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env); 120462: 57 push %edi <== NOT EXECUTED 120463: 68 24 03 12 00 push $0x120324 <== NOT EXECUTED 120468: 68 84 3b 14 00 push $0x143b84 <== NOT EXECUTED 12046d: 6a 00 push $0x0 <== NOT EXECUTED 12046f: e8 fc 0f 00 00 call 121470 <== NOT EXECUTED 120474: 89 c7 mov %eax,%edi <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 120476: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120479: 85 c0 test %eax,%eax <== NOT EXECUTED 12047b: 74 13 je 120490 <== NOT EXECUTED /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 12047d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120480: 56 push %esi <== NOT EXECUTED 120481: e8 96 9b fe ff call 10a01c <== NOT EXECUTED 120486: 89 fb mov %edi,%ebx <== NOT EXECUTED 120488: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12048b: e9 80 00 00 00 jmp 120510 <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; 120490: 89 35 84 3b 14 00 mov %esi,0x143b84 <== NOT EXECUTED }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 120496: 8b 3d 84 3b 14 00 mov 0x143b84,%edi <== NOT EXECUTED 12049c: be 84 9f 15 00 mov $0x159f84,%esi <== NOT EXECUTED 1204a1: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 1204a6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_current_user_env->task_id=task_id; /* mark the local values*/ 1204a8: 8b 15 84 3b 14 00 mov 0x143b84,%edx <== NOT EXECUTED 1204ae: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1204b1: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 1204b3: 8d 7a 14 lea 0x14(%edx),%edi <== NOT EXECUTED 1204b6: a1 24 9b 15 00 mov 0x159b24,%eax <== NOT EXECUTED 1204bb: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 1204be: b1 04 mov $0x4,%cl <== NOT EXECUTED 1204c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * code we must _not_ free the original locs because * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 1204c2: 6a 00 push $0x0 <== NOT EXECUTED 1204c4: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1204c7: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 1204ca: 50 push %eax <== NOT EXECUTED 1204cb: 6a 00 push $0x0 <== NOT EXECUTED 1204cd: 68 33 d0 13 00 push $0x13d033 <== NOT EXECUTED 1204d2: e8 23 9a fe ff call 109efa <== NOT EXECUTED rtems_filesystem_root = loc; 1204d7: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 1204dc: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 1204df: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1204e4: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 1204e7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_evaluate_path("/", 0, &loc, 0); 1204e9: 6a 00 push $0x0 <== NOT EXECUTED 1204eb: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1204ee: 50 push %eax <== NOT EXECUTED 1204ef: 6a 00 push $0x0 <== NOT EXECUTED 1204f1: 68 33 d0 13 00 push $0x13d033 <== NOT EXECUTED 1204f6: e8 ff 99 fe ff call 109efa <== NOT EXECUTED rtems_filesystem_current = loc; 1204fb: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 120500: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 120503: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 120508: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 12050b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12050d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 120510: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120512: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120515: 5b pop %ebx <== NOT EXECUTED 120516: 5e pop %esi <== NOT EXECUTED 120517: 5f pop %edi <== NOT EXECUTED 120518: c9 leave <== NOT EXECUTED 120519: c3 ret <== NOT EXECUTED 0012037b : * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ #ifndef HAVE_USERENV_REFCNT rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 12037b: 55 push %ebp <== NOT EXECUTED 12037c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12037e: 53 push %ebx <== NOT EXECUTED 12037f: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED rtems_status_code sc; rtems_user_env_t * shared_user_env; rtems_id current_task_id; sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id); 120382: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 120385: 50 push %eax <== NOT EXECUTED 120386: 6a 00 push $0x0 <== NOT EXECUTED 120388: 6a 00 push $0x0 <== NOT EXECUTED 12038a: e8 7d 0d 00 00 call 12110c <== NOT EXECUTED 12038f: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 120391: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120394: 85 c0 test %eax,%eax <== NOT EXECUTED 120396: 75 7a jne 120412 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 120398: 8b 1d 84 3b 14 00 mov 0x143b84,%ebx <== NOT EXECUTED 12039e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1203a0: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED 1203a3: 75 23 jne 1203c8 <== NOT EXECUTED /* kill the current user env & task_var*/ rtems_user_env_t *tmp = rtems_current_user_env; sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env); 1203a5: 51 push %ecx <== NOT EXECUTED 1203a6: 51 push %ecx <== NOT EXECUTED 1203a7: 68 84 3b 14 00 push $0x143b84 <== NOT EXECUTED 1203ac: 6a 00 push $0x0 <== NOT EXECUTED 1203ae: e8 55 11 00 00 call 121508 <== NOT EXECUTED 1203b3: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 1203b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1203b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1203ba: 75 56 jne 120412 <== NOT EXECUTED free_user_env(tmp); 1203bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1203bf: 53 push %ebx <== NOT EXECUTED 1203c0: e8 5f ff ff ff call 120324 <== NOT EXECUTED 1203c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED }; /* AT THIS POINT, rtems_current_user_env is DANGLING */ sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, 1203c8: 52 push %edx <== NOT EXECUTED 1203c9: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1203cc: 50 push %eax <== NOT EXECUTED 1203cd: 68 84 3b 14 00 push $0x143b84 <== NOT EXECUTED 1203d2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1203d5: e8 ae 11 00 00 call 121588 <== NOT EXECUTED 1203da: 89 c2 mov %eax,%edx <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 1203dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1203df: 85 c0 test %eax,%eax <== NOT EXECUTED 1203e1: 75 25 jne 120408 <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 1203e3: 50 push %eax <== NOT EXECUTED 1203e4: 68 24 03 12 00 push $0x120324 <== NOT EXECUTED 1203e9: 68 84 3b 14 00 push $0x143b84 <== NOT EXECUTED 1203ee: 6a 00 push $0x0 <== NOT EXECUTED 1203f0: e8 7b 10 00 00 call 121470 <== NOT EXECUTED 1203f5: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 1203f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1203fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1203fc: 75 0a jne 120408 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 1203fe: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 120401: a3 84 3b 14 00 mov %eax,0x143b84 <== NOT EXECUTED 120406: eb 0a jmp 120412 <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 120408: c7 05 84 3b 14 00 84 movl $0x159f84,0x143b84 <== NOT EXECUTED 12040f: 9f 15 00 <== NOT EXECUTED return sc; } 120412: 89 d0 mov %edx,%eax <== NOT EXECUTED 120414: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120417: c9 leave <== NOT EXECUTED 120418: c3 ret <== NOT EXECUTED 0010cdb8 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10cdb8: 55 push %ebp <== NOT EXECUTED 10cdb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdbb: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10cdbe: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cdc0: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10cdc3: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED 10cdc8: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10cdcb: 74 0f je 10cddc <== NOT EXECUTED fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10cdcd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cdcf: f6 c1 02 test $0x2,%cl <== NOT EXECUTED 10cdd2: 75 08 jne 10cddc <== NOT EXECUTED 10cdd4: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cdd6: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 10cdd9: 83 e2 01 and $0x1,%edx <== 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 ) { 10cddc: f6 c1 01 test $0x1,%cl <== NOT EXECUTED 10cddf: 74 03 je 10cde4 <== NOT EXECUTED fcntl_flags |= O_NONBLOCK; 10cde1: 80 ce 40 or $0x40,%dh <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10cde4: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 10cde7: 74 03 je 10cdec <== NOT EXECUTED fcntl_flags |= O_APPEND; 10cde9: 83 ca 08 or $0x8,%edx <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10cdec: 80 e5 04 and $0x4,%ch <== NOT EXECUTED 10cdef: 74 03 je 10cdf4 <== NOT EXECUTED fcntl_flags |= O_CREAT; 10cdf1: 80 ce 02 or $0x2,%dh <== NOT EXECUTED } return fcntl_flags; } 10cdf4: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cdf6: c9 leave <== NOT EXECUTED 10cdf7: c3 ret <== NOT EXECUTED 0010a574 : * size and thus we skip updating the statistics. */ void rtems_malloc_statistics_at_free( void *pointer ) { 10a574: 55 push %ebp <== NOT EXECUTED 10a575: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a577: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED size_t size; if (_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, pointer, &size) ) { 10a57a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a57d: 50 push %eax <== NOT EXECUTED 10a57e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a581: 68 a0 9a 15 00 push $0x159aa0 <== NOT EXECUTED 10a586: e8 19 4e 00 00 call 10f3a4 <_Protected_heap_Get_block_size> <== NOT EXECUTED 10a58b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a58e: 84 c0 test %al,%al <== NOT EXECUTED 10a590: 74 11 je 10a5a3 <== NOT EXECUTED MSBUMP(lifetime_freed, size); 10a592: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10a595: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a597: 01 05 1c 9b 15 00 add %eax,0x159b1c <== NOT EXECUTED 10a59d: 11 15 20 9b 15 00 adc %edx,0x159b20 <== NOT EXECUTED } } 10a5a3: c9 leave <== NOT EXECUTED 10a5a4: c3 ret <== NOT EXECUTED 0010a5a5 : } void rtems_malloc_statistics_at_malloc( void *pointer ) { 10a5a5: 55 push %ebp <== NOT EXECUTED 10a5a6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5a8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a5ab: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED size_t actual_size = 0; uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 10a5ae: 85 d2 test %edx,%edx <== NOT EXECUTED 10a5b0: 74 49 je 10a5fb <== NOT EXECUTED void rtems_malloc_statistics_at_malloc( void *pointer ) { size_t actual_size = 0; 10a5b2: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) return; _Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, pointer, &actual_size); 10a5b9: 50 push %eax <== NOT EXECUTED 10a5ba: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a5bd: 50 push %eax <== NOT EXECUTED 10a5be: 52 push %edx <== NOT EXECUTED 10a5bf: 68 a0 9a 15 00 push $0x159aa0 <== NOT EXECUTED 10a5c4: e8 db 4d 00 00 call 10f3a4 <_Protected_heap_Get_block_size> <== NOT EXECUTED MSBUMP(lifetime_allocated, actual_size); 10a5c9: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10a5cc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a5ce: 03 05 14 9b 15 00 add 0x159b14,%eax <== NOT EXECUTED 10a5d4: 13 15 18 9b 15 00 adc 0x159b18,%edx <== NOT EXECUTED 10a5da: a3 14 9b 15 00 mov %eax,0x159b14 <== NOT EXECUTED 10a5df: 89 15 18 9b 15 00 mov %edx,0x159b18 <== NOT EXECUTED current_depth = s->lifetime_allocated - s->lifetime_freed; 10a5e5: 2b 05 1c 9b 15 00 sub 0x159b1c,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10a5eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5ee: 3b 05 10 9b 15 00 cmp 0x159b10,%eax <== NOT EXECUTED 10a5f4: 76 05 jbe 10a5fb <== NOT EXECUTED s->max_depth = current_depth; 10a5f6: a3 10 9b 15 00 mov %eax,0x159b10 <== NOT EXECUTED } 10a5fb: c9 leave <== NOT EXECUTED 10a5fc: c3 ret <== NOT EXECUTED 0010a5fd : #include #include void rtems_malloc_statistics_initialize( void ) { 10a5fd: 55 push %ebp <== NOT EXECUTED 10a5fe: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a600: 57 push %edi <== NOT EXECUTED 10a601: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* * Zero all the statistics */ (void) memset(&rtems_malloc_statistics, 0, sizeof(rtems_malloc_statistics)); 10a604: bf f8 9a 15 00 mov $0x159af8,%edi <== NOT EXECUTED 10a609: b9 0b 00 00 00 mov $0xb,%ecx <== NOT EXECUTED 10a60e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a610: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED } 10a612: 5a pop %edx <== NOT EXECUTED 10a613: 5f pop %edi <== NOT EXECUTED 10a614: c9 leave <== NOT EXECUTED 10a615: c3 ret <== NOT EXECUTED 001085d0 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 1085d0: 55 push %ebp <== NOT EXECUTED 1085d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1085d3: 56 push %esi <== NOT EXECUTED 1085d4: 53 push %ebx <== NOT EXECUTED 1085d5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED void *return_this; /* * Parameter error checks */ if ( !pointer ) 1085d8: 85 f6 test %esi,%esi <== NOT EXECUTED 1085da: 74 55 je 108631 <== NOT EXECUTED return EINVAL; *pointer = NULL; 1085dc: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1085e2: 83 3d cc 0a 12 00 03 cmpl $0x3,0x120acc <== NOT EXECUTED 1085e9: 75 09 jne 1085f4 <== NOT EXECUTED 1085eb: e8 14 f2 ff ff call 107804 <== NOT EXECUTED 1085f0: 84 c0 test %al,%al <== NOT EXECUTED 1085f2: 74 3d je 108631 <== NOT EXECUTED /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1085f4: e8 62 f2 ff ff call 10785b <== NOT EXECUTED /* * Perform the aligned allocation requested */ return_this = _Protected_heap_Allocate_aligned( 1085f9: 50 push %eax <== NOT EXECUTED 1085fa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1085fd: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108600: 68 e4 07 12 00 push $0x1207e4 <== NOT EXECUTED 108605: e8 66 3f 00 00 call 10c570 <_Protected_heap_Allocate_aligned> <== NOT EXECUTED 10860a: 89 c3 mov %eax,%ebx <== NOT EXECUTED &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 10860c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10860f: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 108614: 85 db test %ebx,%ebx <== NOT EXECUTED 108616: 74 1e je 108636 <== NOT EXECUTED return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 108618: a1 14 e9 11 00 mov 0x11e914,%eax <== NOT EXECUTED 10861d: 85 c0 test %eax,%eax <== NOT EXECUTED 10861f: 74 0a je 10862b <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 108621: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108624: 56 push %esi <== NOT EXECUTED 108625: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 108628: 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; 10862b: 89 1e mov %ebx,(%esi) <== NOT EXECUTED 10862d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10862f: eb 05 jmp 108636 <== NOT EXECUTED return 0; 108631: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 108636: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108639: 5b pop %ebx <== NOT EXECUTED 10863a: 5e pop %esi <== NOT EXECUTED 10863b: c9 leave <== NOT EXECUTED 10863c: c3 ret <== NOT EXECUTED 00110ca4 : Objects_Id id, const void *buffer, size_t size, uint32_t *count ) { 110ca4: 55 push %ebp <== NOT EXECUTED 110ca5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110ca7: 57 push %edi <== NOT EXECUTED 110ca8: 56 push %esi <== NOT EXECUTED 110ca9: 53 push %ebx <== NOT EXECUTED 110caa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 110cad: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 110cb0: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 110cb3: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 110cb6: 85 ff test %edi,%edi <== NOT EXECUTED 110cb8: 74 4f je 110d09 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !count ) 110cba: 85 db test %ebx,%ebx <== NOT EXECUTED 110cbc: 74 4b je 110d09 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 110cbe: 52 push %edx <== NOT EXECUTED 110cbf: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 110cc2: 50 push %eax <== NOT EXECUTED 110cc3: 56 push %esi <== NOT EXECUTED 110cc4: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110cc9: e8 5e 42 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110cce: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110cd0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110cd3: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110cd8: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 110cdc: 75 30 jne 110d0e <== NOT EXECUTED case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 110cde: 50 push %eax <== NOT EXECUTED 110cdf: 50 push %eax <== NOT EXECUTED 110ce0: 53 push %ebx <== NOT EXECUTED 110ce1: 6a 00 push $0x0 <== NOT EXECUTED 110ce3: 56 push %esi <== NOT EXECUTED 110ce4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 110ce7: 57 push %edi <== NOT EXECUTED 110ce8: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 110ceb: 50 push %eax <== NOT EXECUTED 110cec: e8 4b 2d 00 00 call 113a3c <_CORE_message_queue_Broadcast> <== NOT EXECUTED 110cf1: 89 c3 mov %eax,%ebx <== NOT EXECUTED NULL, #endif count ); _Thread_Enable_dispatch(); 110cf3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 110cf6: e8 f1 49 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED return 110cfb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110cfe: 53 push %ebx <== NOT EXECUTED 110cff: e8 00 03 00 00 call 111004 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 110d04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110d07: eb 05 jmp 110d0e <== NOT EXECUTED 110d09: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110d0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110d11: 5b pop %ebx <== NOT EXECUTED 110d12: 5e pop %esi <== NOT EXECUTED 110d13: 5f pop %edi <== NOT EXECUTED 110d14: c9 leave <== NOT EXECUTED 110d15: c3 ret <== NOT EXECUTED 0010d400 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 10d400: 55 push %ebp <== NOT EXECUTED 10d401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d403: 57 push %edi <== NOT EXECUTED 10d404: 56 push %esi <== NOT EXECUTED 10d405: 53 push %ebx <== NOT EXECUTED 10d406: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10d409: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d40c: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 10d40f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10d414: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10d418: 0f 84 b2 00 00 00 je 10d4d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10d41e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10d423: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 10d427: 0f 84 a3 00 00 00 je 10d4d0 <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10d42d: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10d432: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10d436: 0f 84 94 00 00 00 je 10d4d0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 10d43c: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED 10d441: 85 ff test %edi,%edi <== NOT EXECUTED 10d443: 0f 84 87 00 00 00 je 10d4d0 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d449: a1 f4 9b 15 00 mov 0x159bf4,%eax <== NOT EXECUTED 10d44e: 40 inc %eax <== NOT EXECUTED 10d44f: a3 f4 9b 15 00 mov %eax,0x159bf4 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10d454: e8 5f 39 01 00 call 120db8 <_Message_queue_Allocate> <== NOT EXECUTED 10d459: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !the_message_queue ) { 10d45b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d45d: 75 0c jne 10d46b <== NOT EXECUTED _Thread_Enable_dispatch(); 10d45f: e8 dc 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d464: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10d469: eb 65 jmp 10d4d0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 10d46b: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 10d46e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d470: f7 c6 04 00 00 00 test $0x4,%esi <== NOT EXECUTED 10d476: 0f 95 c0 setne %al <== NOT EXECUTED 10d479: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 10d47c: 57 push %edi <== NOT EXECUTED 10d47d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d480: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d483: 50 push %eax <== NOT EXECUTED 10d484: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10d487: 50 push %eax <== NOT EXECUTED 10d488: e8 8f 0d 00 00 call 10e21c <_CORE_message_queue_Initialize> <== NOT EXECUTED 10d48d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d490: 84 c0 test %al,%al <== NOT EXECUTED 10d492: 75 1c jne 10d4b0 <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 10d494: 50 push %eax <== NOT EXECUTED 10d495: 50 push %eax <== NOT EXECUTED 10d496: 53 push %ebx <== NOT EXECUTED 10d497: 68 cc 9f 15 00 push $0x159fcc <== NOT EXECUTED 10d49c: e8 23 1a 00 00 call 10eec4 <_Objects_Free> <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 10d4a1: e8 9a 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d4a6: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10d4ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4ae: eb 20 jmp 10d4d0 <== NOT EXECUTED 10d4b0: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10d4b3: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10d4b6: a1 e8 9f 15 00 mov 0x159fe8,%eax <== NOT EXECUTED 10d4bb: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10d4be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d4c1: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 10d4c4: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10d4c7: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 ); #endif _Thread_Enable_dispatch(); 10d4c9: e8 72 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d4ce: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10d4d0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d4d3: 5b pop %ebx <== NOT EXECUTED 10d4d4: 5e pop %esi <== NOT EXECUTED 10d4d5: 5f pop %edi <== NOT EXECUTED 10d4d6: c9 leave <== NOT EXECUTED 10d4d7: c3 ret <== NOT EXECUTED 0011248c : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 11248c: 55 push %ebp <== NOT EXECUTED 11248d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11248f: 53 push %ebx <== NOT EXECUTED 112490: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 112493: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112496: 50 push %eax <== NOT EXECUTED 112497: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11249a: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 11249f: e8 d8 b7 ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED 1124a4: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1124a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1124a9: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1124ae: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1124b2: 75 34 jne 1124e8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 1124b4: 51 push %ecx <== NOT EXECUTED 1124b5: 51 push %ecx <== NOT EXECUTED 1124b6: 53 push %ebx <== NOT EXECUTED 1124b7: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 1124bc: e8 eb b3 ff ff call 10d8ac <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 1124c1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1124c4: 6a 05 push $0x5 <== NOT EXECUTED 1124c6: 6a 00 push $0x0 <== NOT EXECUTED 1124c8: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1124cb: 50 push %eax <== NOT EXECUTED 1124cc: e8 7b 04 00 00 call 11294c <_CORE_message_queue_Close> <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 1124d1: 58 pop %eax <== NOT EXECUTED 1124d2: 5a pop %edx <== NOT EXECUTED 1124d3: 53 push %ebx <== NOT EXECUTED 1124d4: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 1124d9: e8 6a b6 ff ff call 10db48 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 1124de: e8 59 bf ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 1124e3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1124e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1124e8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1124eb: c9 leave <== NOT EXECUTED 1124ec: c3 ret <== NOT EXECUTED 00110e54 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 110e54: 55 push %ebp <== NOT EXECUTED 110e55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e57: 53 push %ebx <== NOT EXECUTED 110e58: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 110e5b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110e5e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110e63: 85 db test %ebx,%ebx <== NOT EXECUTED 110e65: 74 3a je 110ea1 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 110e67: 50 push %eax <== NOT EXECUTED 110e68: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110e6b: 50 push %eax <== NOT EXECUTED 110e6c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110e6f: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110e74: e8 b3 40 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110e79: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110e7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110e7e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110e83: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110e87: 75 18 jne 110ea1 <== NOT EXECUTED case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 110e89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110e8c: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 110e8f: 50 push %eax <== NOT EXECUTED 110e90: e8 47 2c 00 00 call 113adc <_CORE_message_queue_Flush> <== NOT EXECUTED 110e95: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 110e97: e8 50 48 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110e9c: 31 c0 xor %eax,%eax <== NOT EXECUTED 110e9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110ea1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110ea4: c9 leave <== NOT EXECUTED 110ea5: c3 ret <== NOT EXECUTED 00110ea8 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 110ea8: 55 push %ebp <== NOT EXECUTED 110ea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110eab: 53 push %ebx <== NOT EXECUTED 110eac: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 110eaf: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110eb2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110eb7: 85 db test %ebx,%ebx <== NOT EXECUTED 110eb9: 74 2e je 110ee9 <== NOT EXECUTED 110ebb: 50 push %eax <== NOT EXECUTED 110ebc: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110ebf: 50 push %eax <== NOT EXECUTED 110ec0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110ec3: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110ec8: e8 5f 40 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110ecd: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110ecf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110ed2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110ed7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110edb: 75 0c jne 110ee9 <== NOT EXECUTED case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 110edd: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 110ee0: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 110ee2: e8 05 48 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110ee7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110ee9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110eec: c9 leave <== NOT EXECUTED 110eed: c3 ret <== NOT EXECUTED 00108e70 : rtems_status_code rtems_message_queue_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 108e70: 55 push %ebp <== NOT EXECUTED 108e71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e73: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 108e76: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108e79: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108e7c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108e7f: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 108e84: e8 bf 18 00 00 call 10a748 <_Objects_Name_to_id_u32> <== NOT EXECUTED 108e89: 8b 04 85 34 68 11 00 mov 0x116834(,%eax,4),%eax <== NOT EXECUTED node, id ); return _Status_Object_name_errors_to_status[ status ]; } 108e90: c9 leave <== NOT EXECUTED 108e91: c3 ret <== NOT EXECUTED 001124f0 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 1124f0: 55 push %ebp <== NOT EXECUTED 1124f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1124f3: 57 push %edi <== NOT EXECUTED 1124f4: 56 push %esi <== NOT EXECUTED 1124f5: 53 push %ebx <== NOT EXECUTED 1124f6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1124f9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 1124fc: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 1124ff: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 112502: 85 ff test %edi,%edi <== NOT EXECUTED 112504: 74 5d je 112563 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 112506: 85 f6 test %esi,%esi <== NOT EXECUTED 112508: 74 59 je 112563 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 11250a: 52 push %edx <== NOT EXECUTED 11250b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11250e: 50 push %eax <== NOT EXECUTED 11250f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112512: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 112517: e8 60 b7 ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED 11251c: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11251e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112521: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112526: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 11252a: 75 3c jne 112568 <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11252c: 50 push %eax <== NOT EXECUTED 11252d: 50 push %eax <== NOT EXECUTED 11252e: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 112531: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 112534: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 112537: 53 push %ebx <== NOT EXECUTED 112538: 56 push %esi <== NOT EXECUTED 112539: 57 push %edi <== NOT EXECUTED 11253a: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 11253d: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 112540: 50 push %eax <== NOT EXECUTED 112541: e8 56 05 00 00 call 112a9c <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 112546: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112549: e8 ee be ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 11254e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112551: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112556: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 112559: e8 66 9d ff ff call 10c2c4 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 11255e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112561: eb 05 jmp 112568 <== NOT EXECUTED 112563: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112568: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11256b: 5b pop %ebx <== NOT EXECUTED 11256c: 5e pop %esi <== NOT EXECUTED 11256d: 5f pop %edi <== NOT EXECUTED 11256e: c9 leave <== NOT EXECUTED 11256f: c3 ret <== NOT EXECUTED 00108e94 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 108e94: 55 push %ebp <== NOT EXECUTED 108e95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e97: 56 push %esi <== NOT EXECUTED 108e98: 53 push %ebx <== NOT EXECUTED 108e99: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108e9c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108e9f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 108ea2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108ea7: 85 f6 test %esi,%esi <== NOT EXECUTED 108ea9: 74 4f je 108efa <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 108eab: 50 push %eax <== NOT EXECUTED 108eac: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 108eaf: 50 push %eax <== NOT EXECUTED 108eb0: 53 push %ebx <== NOT EXECUTED 108eb1: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 108eb6: e8 45 17 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 108ebb: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 108ebd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ec0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 108ec5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 108ec9: 75 2f jne 108efa <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 108ecb: 6a 00 push $0x0 <== NOT EXECUTED 108ecd: 6a 00 push $0x0 <== NOT EXECUTED 108ecf: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 108ed4: 6a 00 push $0x0 <== NOT EXECUTED 108ed6: 53 push %ebx <== NOT EXECUTED 108ed7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108eda: 56 push %esi <== NOT EXECUTED 108edb: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 108ede: 50 push %eax <== NOT EXECUTED 108edf: e8 88 0b 00 00 call 109a6c <_CORE_message_queue_Submit> <== NOT EXECUTED 108ee4: 89 c3 mov %eax,%ebx <== NOT EXECUTED MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 108ee6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108ee9: e8 d2 1e 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 108eee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ef1: 53 push %ebx <== NOT EXECUTED 108ef2: e8 0d 00 00 00 call 108f04 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 108ef7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 108efa: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108efd: 5b pop %ebx <== NOT EXECUTED 108efe: 5e pop %esi <== NOT EXECUTED 108eff: c9 leave <== NOT EXECUTED 108f00: c3 ret <== NOT EXECUTED 00111014 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 111014: 55 push %ebp <== NOT EXECUTED 111015: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111017: 56 push %esi <== NOT EXECUTED 111018: 53 push %ebx <== NOT EXECUTED 111019: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11101c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 11101f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 111022: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 111027: 85 f6 test %esi,%esi <== NOT EXECUTED 111029: 74 4f je 11107a <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 11102b: 50 push %eax <== NOT EXECUTED 11102c: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11102f: 50 push %eax <== NOT EXECUTED 111030: 53 push %ebx <== NOT EXECUTED 111031: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 111036: e8 f1 3e 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 11103b: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11103d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111040: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111045: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 111049: 75 2f jne 11107a <== NOT EXECUTED size_t size 11104b: 6a 00 push $0x0 <== NOT EXECUTED 11104d: 6a 00 push $0x0 <== NOT EXECUTED 11104f: 68 00 00 00 80 push $0x80000000 <== NOT EXECUTED 111054: 6a 00 push $0x0 <== NOT EXECUTED 111056: 53 push %ebx <== NOT EXECUTED 111057: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11105a: 56 push %esi <== NOT EXECUTED 11105b: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 11105e: 50 push %eax <== NOT EXECUTED 11105f: e8 cc 2c 00 00 call 113d30 <_CORE_message_queue_Submit> <== NOT EXECUTED 111064: 89 c3 mov %eax,%ebx <== NOT EXECUTED id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 111066: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 111069: e8 7e 46 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 11106e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111071: 53 push %ebx <== NOT EXECUTED 111072: e8 8d ff ff ff call 111004 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 111077: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11107a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11107d: 5b pop %ebx <== NOT EXECUTED 11107e: 5e pop %esi <== NOT EXECUTED 11107f: c9 leave <== NOT EXECUTED 111080: c3 ret <== NOT EXECUTED 0010a35c : #include int rtems_object_api_maximum_class( uint32_t api ) { 10a35c: 55 push %ebp <== NOT EXECUTED 10a35d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10a35f: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10a360: e9 13 15 00 00 jmp 10b878 <_Objects_API_maximum_class> <== NOT EXECUTED 0010a368 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10a368: 55 push %ebp <== NOT EXECUTED 10a369: 89 e5 mov %esp,%ebp <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a36b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a36e: 48 dec %eax <== NOT EXECUTED 10a36f: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10a372: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10a374: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10a377: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10a378: c9 leave <== NOT EXECUTED 10a379: c3 ret <== NOT EXECUTED 0010a37c : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10a37c: 55 push %ebp <== NOT EXECUTED 10a37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a37f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a382: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a385: b8 c8 e3 11 00 mov $0x11e3c8,%eax <== NOT EXECUTED 10a38a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10a38d: 74 0f je 10a39e <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10a38f: b8 04 a5 11 00 mov $0x11a504,%eax <== NOT EXECUTED 10a394: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10a397: 75 20 jne 10a3b9 <== NOT EXECUTED 10a399: b8 e0 e3 11 00 mov $0x11e3e0,%eax <== NOT EXECUTED else if ( the_api == OBJECTS_ITRON_API ) api_assoc = rtems_object_api_itron_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); 10a39e: 52 push %edx <== NOT EXECUTED 10a39f: 52 push %edx <== NOT EXECUTED 10a3a0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a3a3: 50 push %eax <== NOT EXECUTED 10a3a4: e8 33 40 00 00 call 10e3dc <== NOT EXECUTED 10a3a9: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( class_assoc ) 10a3ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3ae: b8 0c a5 11 00 mov $0x11a50c,%eax <== NOT EXECUTED 10a3b3: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3b5: 74 02 je 10a3b9 <== NOT EXECUTED return class_assoc->name; 10a3b7: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a3b9: c9 leave <== NOT EXECUTED 10a3ba: c3 ret <== NOT EXECUTED 0010a3bc : }; const char *rtems_object_get_api_name( uint32_t api ) { 10a3bc: 55 push %ebp <== NOT EXECUTED 10a3bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3bf: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10a3c2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a3c5: 68 58 e4 11 00 push $0x11e458 <== NOT EXECUTED 10a3ca: e8 0d 40 00 00 call 10e3dc <== NOT EXECUTED 10a3cf: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( api_assoc ) 10a3d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3d4: b8 0c a5 11 00 mov $0x11a50c,%eax <== NOT EXECUTED 10a3d9: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3db: 74 02 je 10a3df <== NOT EXECUTED return api_assoc->name; 10a3dd: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a3df: c9 leave <== NOT EXECUTED 10a3e0: c3 ret <== NOT EXECUTED 0010a41c : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10a41c: 55 push %ebp <== NOT EXECUTED 10a41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a41f: 57 push %edi <== NOT EXECUTED 10a420: 56 push %esi <== NOT EXECUTED 10a421: 53 push %ebx <== NOT EXECUTED 10a422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a425: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10a428: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a42d: 85 ff test %edi,%edi <== NOT EXECUTED 10a42f: 74 50 je 10a481 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10a431: 50 push %eax <== NOT EXECUTED 10a432: 50 push %eax <== NOT EXECUTED 10a433: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a436: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a439: e8 9a 17 00 00 call 10bbd8 <_Objects_Get_information> <== NOT EXECUTED 10a43e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !obj_info ) 10a440: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a443: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a448: 85 db test %ebx,%ebx <== NOT EXECUTED 10a44a: 74 35 je 10a481 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10a44c: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a44f: 89 07 mov %eax,(%edi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10a451: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a454: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10a457: 8a 43 12 mov 0x12(%ebx),%al <== NOT EXECUTED 10a45a: 88 47 0c mov %al,0xc(%edi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10a45d: 0f b7 73 10 movzwl 0x10(%ebx),%esi <== NOT EXECUTED 10a461: 89 77 08 mov %esi,0x8(%edi) <== NOT EXECUTED 10a464: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a466: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a46b: eb 0b jmp 10a478 <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) if ( !obj_info->local_table[i] ) 10a46d: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED unallocated++; 10a470: 83 3c 90 01 cmpl $0x1,(%eax,%edx,4) <== NOT EXECUTED 10a474: 83 d1 00 adc $0x0,%ecx <== NOT EXECUTED info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10a477: 42 inc %edx <== NOT EXECUTED 10a478: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a47a: 76 f1 jbe 10a46d <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10a47c: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED 10a47f: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a481: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a484: 5b pop %ebx <== NOT EXECUTED 10a485: 5e pop %esi <== NOT EXECUTED 10a486: 5f pop %edi <== NOT EXECUTED 10a487: c9 leave <== NOT EXECUTED 10a488: c3 ret <== NOT EXECUTED 00109d28 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 109d28: 55 push %ebp <== NOT EXECUTED 109d29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d2b: 53 push %ebx <== NOT EXECUTED 109d2c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109d2f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 109d32: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109d37: 85 db test %ebx,%ebx <== NOT EXECUTED 109d39: 74 1d je 109d58 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 109d3b: 50 push %eax <== NOT EXECUTED 109d3c: 50 push %eax <== NOT EXECUTED 109d3d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109d40: 50 push %eax <== NOT EXECUTED 109d41: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d44: e8 57 18 00 00 call 10b5a0 <_Objects_Id_to_name> <== NOT EXECUTED *name = name_u.name_u32; 109d49: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 109d4c: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 109d4e: 8b 04 85 0c 96 11 00 mov 0x11960c(,%eax,4),%eax <== NOT EXECUTED 109d55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d58: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109d5b: c9 leave <== NOT EXECUTED 109d5c: c3 ret <== NOT EXECUTED 001125e4 : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 1125e4: 55 push %ebp <== NOT EXECUTED 1125e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 1125e7: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 1125e8: e9 2b 09 00 00 jmp 112f18 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010a498 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10a498: 55 push %ebp <== NOT EXECUTED 10a499: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10a49b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a4a0: c9 leave <== NOT EXECUTED 10a4a1: c3 ret <== NOT EXECUTED 0010a4a4 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10a4a4: 55 push %ebp <== NOT EXECUTED 10a4a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10a4a7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a4ac: c9 leave <== NOT EXECUTED 10a4ad: c3 ret <== NOT EXECUTED 0010a4b0 : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10a4b0: 55 push %ebp <== NOT EXECUTED 10a4b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4b6: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a4b9: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10a4bc: c9 leave <== NOT EXECUTED 10a4bd: c3 ret <== NOT EXECUTED 0010a4c0 : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10a4c0: 55 push %ebp <== NOT EXECUTED 10a4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4c6: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10a4c9: c9 leave <== NOT EXECUTED 10a4ca: c3 ret <== NOT EXECUTED 0010a4cc : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10a4cc: 55 push %ebp <== NOT EXECUTED 10a4cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4cf: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10a4d3: c9 leave <== NOT EXECUTED 10a4d4: c3 ret <== NOT EXECUTED 0010a4d8 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10a4df: c9 leave <== NOT EXECUTED 10a4e0: c3 ret <== NOT EXECUTED 0010a4e4 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10a4e4: 55 push %ebp <== NOT EXECUTED 10a4e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4e7: 57 push %edi <== NOT EXECUTED 10a4e8: 56 push %esi <== NOT EXECUTED 10a4e9: 53 push %ebx <== NOT EXECUTED 10a4ea: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a4ed: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a4f0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a4f5: 85 ff test %edi,%edi <== NOT EXECUTED 10a4f7: 74 50 je 10a549 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a4f9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4fc: 85 db test %ebx,%ebx <== NOT EXECUTED 10a4fe: 75 08 jne 10a508 <== NOT EXECUTED 10a500: a1 2c 06 12 00 mov 0x12062c,%eax <== NOT EXECUTED 10a505: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10a508: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a50b: 53 push %ebx <== NOT EXECUTED 10a50c: e8 a7 16 00 00 call 10bbb8 <_Objects_Get_information_id> <== NOT EXECUTED 10a511: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10a513: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a516: 85 c0 test %eax,%eax <== NOT EXECUTED 10a518: 74 2a je 10a544 <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10a51a: 51 push %ecx <== NOT EXECUTED 10a51b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a51e: 50 push %eax <== NOT EXECUTED 10a51f: 53 push %ebx <== NOT EXECUTED 10a520: 56 push %esi <== NOT EXECUTED 10a521: e8 2a 18 00 00 call 10bd50 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10a526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a529: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10a52d: 75 15 jne 10a544 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10a52f: 52 push %edx <== NOT EXECUTED 10a530: 57 push %edi <== NOT EXECUTED 10a531: 50 push %eax <== NOT EXECUTED 10a532: 56 push %esi <== NOT EXECUTED 10a533: e8 54 1a 00 00 call 10bf8c <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a538: e8 33 21 00 00 call 10c670 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a53d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a53f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a542: eb 05 jmp 10a549 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 10a544: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a549: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a54c: 5b pop %ebx <== NOT EXECUTED 10a54d: 5e pop %esi <== NOT EXECUTED 10a54e: 5f pop %edi <== NOT EXECUTED 10a54f: c9 leave <== NOT EXECUTED 10a550: c3 ret <== NOT EXECUTED 00109590 : void rtems_panic( const char *printf_format, ... ) { 109590: 55 push %ebp <== NOT EXECUTED 109591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109593: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109596: 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); 109599: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10959c: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 1095a1: e8 83 fe ff ff call 109429 <== NOT EXECUTED va_end(arglist); } 1095a6: c9 leave <== NOT EXECUTED 1095a7: c3 ret <== NOT EXECUTED 00111084 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 111084: 55 push %ebp <== NOT EXECUTED 111085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111087: 57 push %edi <== NOT EXECUTED 111088: 56 push %esi <== NOT EXECUTED 111089: 53 push %ebx <== NOT EXECUTED 11108a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11108d: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 111090: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 111093: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 111098: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11109c: 0f 84 c9 00 00 00 je 11116b <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 1110a2: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 1110a6: 0f 84 b3 00 00 00 je 11115f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 1110ac: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 1110b0: 0f 84 a9 00 00 00 je 11115f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 1110b6: 85 ff test %edi,%edi <== NOT EXECUTED 1110b8: 0f 84 a8 00 00 00 je 111166 <== NOT EXECUTED 1110be: 85 f6 test %esi,%esi <== NOT EXECUTED 1110c0: 0f 84 a0 00 00 00 je 111166 <== NOT EXECUTED 1110c6: 39 f7 cmp %esi,%edi <== NOT EXECUTED 1110c8: 0f 82 98 00 00 00 jb 111166 <== NOT EXECUTED 1110ce: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 1110d4: 0f 85 8c 00 00 00 jne 111166 <== NOT EXECUTED !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1110da: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 1110de: 75 7f jne 11115f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1110e0: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1110e5: 40 inc %eax <== NOT EXECUTED 1110e6: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of 1110eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1110ee: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1110f3: e8 b4 39 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 1110f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1110fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1110fd: 85 c0 test %eax,%eax <== NOT EXECUTED 1110ff: 75 0c jne 11110d <== NOT EXECUTED _Thread_Enable_dispatch(); 111101: e8 e6 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111106: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 11110b: eb 5e jmp 11116b <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 11110d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111110: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_partition->length = length; 111113: 89 7b 14 mov %edi,0x14(%ebx) <== NOT EXECUTED the_partition->buffer_size = buffer_size; 111116: 89 73 18 mov %esi,0x18(%ebx) <== NOT EXECUTED the_partition->attribute_set = attribute_set; 111119: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11111c: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED the_partition->number_of_used_blocks = 0; 11111f: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED _Chain_Initialize( &the_partition->Memory, starting_address, 111126: 56 push %esi <== NOT EXECUTED 111127: 89 f8 mov %edi,%eax <== NOT EXECUTED 111129: 31 d2 xor %edx,%edx <== NOT EXECUTED 11112b: f7 f6 div %esi <== NOT EXECUTED 11112d: 50 push %eax <== NOT EXECUTED 11112e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111131: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 111134: 50 push %eax <== NOT EXECUTED 111135: e8 ca 28 00 00 call 113a04 <_Chain_Initialize> <== NOT EXECUTED 11113a: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 11113d: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 111140: a1 30 26 13 00 mov 0x132630,%eax <== NOT EXECUTED 111145: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 111148: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11114b: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 11114e: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 111151: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 111153: e8 94 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111158: 31 c0 xor %eax,%eax <== NOT EXECUTED 11115a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11115d: eb 0c jmp 11116b <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11115f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 111164: eb 05 jmp 11116b <== NOT EXECUTED 111166: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED } 11116b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11116e: 5b pop %ebx <== NOT EXECUTED 11116f: 5e pop %esi <== NOT EXECUTED 111170: 5f pop %edi <== NOT EXECUTED 111171: c9 leave <== NOT EXECUTED 111172: c3 ret <== NOT EXECUTED 00111174 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 111174: 55 push %ebp <== NOT EXECUTED 111175: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111177: 53 push %ebx <== NOT EXECUTED 111178: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 11117b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11117e: 50 push %eax <== NOT EXECUTED 11117f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111182: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 111187: e8 a0 3d 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 11118c: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 11118e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111191: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111196: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11119a: 75 36 jne 1111d2 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 11119c: 83 7b 20 00 cmpl $0x0,0x20(%ebx) <== NOT EXECUTED 1111a0: 75 26 jne 1111c8 <== NOT EXECUTED _Objects_Close( &_Partition_Information, &the_partition->Object ); 1111a2: 51 push %ecx <== NOT EXECUTED 1111a3: 51 push %ecx <== NOT EXECUTED 1111a4: 53 push %ebx <== NOT EXECUTED 1111a5: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111aa: e8 71 39 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED size_t *size ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. 1111af: 58 pop %eax <== NOT EXECUTED 1111b0: 5a pop %edx <== NOT EXECUTED 1111b1: 53 push %ebx <== NOT EXECUTED 1111b2: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111b7: e8 00 3c 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1111bc: e8 2b 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1111c1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1111c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1111c6: eb 0a jmp 1111d2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1111c8: e8 1f 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1111cd: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1111d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1111d5: c9 leave <== NOT EXECUTED 1111d6: c3 ret <== NOT EXECUTED 001111d8 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 1111d8: 55 push %ebp <== NOT EXECUTED 1111d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1111db: 57 push %edi <== NOT EXECUTED 1111dc: 56 push %esi <== NOT EXECUTED 1111dd: 53 push %ebx <== NOT EXECUTED 1111de: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1111e1: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 1111e4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1111e9: 85 ff test %edi,%edi <== NOT EXECUTED 1111eb: 74 4f je 11123c <== 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. 1111ed: 50 push %eax <== NOT EXECUTED 1111ee: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1111f1: 50 push %eax <== NOT EXECUTED 1111f2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1111f5: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111fa: e8 2d 3d 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1111ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 111201: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111204: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111209: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 11120d: 75 2d jne 11123c <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 11120f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111212: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 111215: 50 push %eax <== NOT EXECUTED 111216: e8 c1 27 00 00 call 1139dc <_Chain_Get> <== NOT EXECUTED 11121b: 89 c6 mov %eax,%esi <== NOT EXECUTED case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 11121d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111220: 85 c0 test %eax,%eax <== NOT EXECUTED 111222: 74 0e je 111232 <== NOT EXECUTED the_partition->number_of_used_blocks += 1; 111224: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 111227: e8 c0 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED *buffer = the_buffer; 11122c: 89 37 mov %esi,(%edi) <== NOT EXECUTED 11122e: 31 c0 xor %eax,%eax <== NOT EXECUTED 111230: eb 0a jmp 11123c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 111232: e8 b5 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111237: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11123c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11123f: 5b pop %ebx <== NOT EXECUTED 111240: 5e pop %esi <== NOT EXECUTED 111241: 5f pop %edi <== NOT EXECUTED 111242: c9 leave <== NOT EXECUTED 111243: c3 ret <== NOT EXECUTED 00111244 : rtems_status_code rtems_partition_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 111244: 55 push %ebp <== NOT EXECUTED 111245: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111247: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Partition_Information, name, node, id ); 11124a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11124d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111250: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111253: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 111258: e8 17 3e 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11125d: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 111264: c9 leave <== NOT EXECUTED 111265: c3 ret <== NOT EXECUTED 00111268 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 111268: 55 push %ebp <== NOT EXECUTED 111269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11126b: 56 push %esi <== NOT EXECUTED 11126c: 53 push %ebx <== NOT EXECUTED 11126d: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111270: 8b 75 0c mov 0xc(%ebp),%esi <== 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. 111273: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111276: 50 push %eax <== NOT EXECUTED 111277: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11127a: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 11127f: e8 a8 3c 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 111284: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 111286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111289: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11128e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 111292: 75 3c jne 1112d0 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 111294: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from 111297: 39 ce cmp %ecx,%esi <== NOT EXECUTED 111299: 0f 93 c0 setae %al <== NOT EXECUTED 11129c: 89 ca mov %ecx,%edx <== NOT EXECUTED 11129e: 03 53 14 add 0x14(%ebx),%edx <== NOT EXECUTED 1112a1: 39 d6 cmp %edx,%esi <== NOT EXECUTED 1112a3: 0f 96 c2 setbe %dl <== NOT EXECUTED 1112a6: 84 c2 test %al,%dl <== NOT EXECUTED 1112a8: 74 2d je 1112d7 <== NOT EXECUTED 1112aa: 89 f0 mov %esi,%eax <== NOT EXECUTED 1112ac: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1112ae: 31 d2 xor %edx,%edx <== NOT EXECUTED 1112b0: f7 73 18 divl 0x18(%ebx) <== NOT EXECUTED 1112b3: 85 d2 test %edx,%edx <== NOT EXECUTED 1112b5: 75 20 jne 1112d7 <== 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( 1112b7: 50 push %eax <== NOT EXECUTED 1112b8: 50 push %eax <== NOT EXECUTED 1112b9: 56 push %esi <== NOT EXECUTED 1112ba: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 1112bd: 50 push %eax <== NOT EXECUTED 1112be: e8 f5 26 00 00 call 1139b8 <_Chain_Append> <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1112c3: ff 4b 20 decl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1112c6: e8 21 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1112cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1112cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1112d0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1112d3: 5b pop %ebx <== NOT EXECUTED 1112d4: 5e pop %esi <== NOT EXECUTED 1112d5: c9 leave <== NOT EXECUTED 1112d6: c3 ret <== NOT EXECUTED _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1112d7: e8 10 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1112dc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1112e1: eb ed jmp 1112d0 <== NOT EXECUTED 001107b8 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 1107b8: 55 push %ebp <== NOT EXECUTED 1107b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1107bb: 57 push %edi <== NOT EXECUTED 1107bc: 56 push %esi <== NOT EXECUTED 1107bd: 53 push %ebx <== NOT EXECUTED 1107be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1107c1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1107c4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 1107c7: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 1107cc: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 1107d0: 74 6f je 110841 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 1107d2: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 1107d6: 74 64 je 11083c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 1107d8: 89 f8 mov %edi,%eax <== NOT EXECUTED 1107da: 09 f0 or %esi,%eax <== NOT EXECUTED 1107dc: a8 03 test $0x3,%al <== NOT EXECUTED 1107de: 75 5c jne 11083c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1107e0: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1107e5: 40 inc %eax <== NOT EXECUTED 1107e6: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 1107eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1107ee: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 1107f3: e8 b4 42 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 1107f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 1107fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1107fd: 85 c0 test %eax,%eax <== NOT EXECUTED 1107ff: 75 0c jne 11080d <== NOT EXECUTED _Thread_Enable_dispatch(); 110801: e8 e6 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110806: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 11080b: eb 34 jmp 110841 <== NOT EXECUTED return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 11080d: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED the_port->external_base = external_start; 110810: 89 78 14 mov %edi,0x14(%eax) <== NOT EXECUTED the_port->length = length - 1; 110813: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 110816: 48 dec %eax <== NOT EXECUTED 110817: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 11081a: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 11081d: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 110820: a1 f0 25 13 00 mov 0x1325f0,%eax <== NOT EXECUTED 110825: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 110828: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11082b: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 11082e: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 110831: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 110833: e8 b4 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110838: 31 c0 xor %eax,%eax <== NOT EXECUTED 11083a: eb 05 jmp 110841 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11083c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 110841: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110844: 5b pop %ebx <== NOT EXECUTED 110845: 5e pop %esi <== NOT EXECUTED 110846: 5f pop %edi <== NOT EXECUTED 110847: c9 leave <== NOT EXECUTED 110848: c3 ret <== NOT EXECUTED 0011084c : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 11084c: 55 push %ebp <== NOT EXECUTED 11084d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11084f: 53 push %ebx <== NOT EXECUTED 110850: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 110853: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110856: 50 push %eax <== NOT EXECUTED 110857: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11085a: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11085f: e8 c8 46 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110864: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 110866: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110869: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11086e: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110872: 75 24 jne 110898 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 110874: 51 push %ecx <== NOT EXECUTED 110875: 51 push %ecx <== NOT EXECUTED 110876: 53 push %ebx <== NOT EXECUTED 110877: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11087c: e8 9f 42 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ 110881: 58 pop %eax <== NOT EXECUTED 110882: 5a pop %edx <== NOT EXECUTED 110883: 53 push %ebx <== NOT EXECUTED 110884: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 110889: e8 2e 45 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 11088e: e8 59 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110893: 31 c0 xor %eax,%eax <== NOT EXECUTED 110895: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110898: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11089b: c9 leave <== NOT EXECUTED 11089c: c3 ret <== NOT EXECUTED 001108a0 : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 1108a0: 55 push %ebp <== NOT EXECUTED 1108a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108a3: 56 push %esi <== NOT EXECUTED 1108a4: 53 push %ebx <== NOT EXECUTED 1108a5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1108a8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1108ab: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 1108ae: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1108b3: 85 db test %ebx,%ebx <== NOT EXECUTED 1108b5: 74 3c je 1108f3 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 1108b7: 50 push %eax <== NOT EXECUTED 1108b8: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1108bb: 50 push %eax <== NOT EXECUTED 1108bc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1108bf: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 1108c4: e8 63 46 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1108c9: 89 c1 mov %eax,%ecx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 1108cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1108ce: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1108d3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1108d7: 75 1a jne 1108f3 <== 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 */ 1108d9: 89 f2 mov %esi,%edx <== NOT EXECUTED 1108db: 2b 51 14 sub 0x14(%ecx),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 1108de: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 1108e1: 76 04 jbe 1108e7 <== NOT EXECUTED *internal = external; 1108e3: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 1108e5: eb 05 jmp 1108ec <== NOT EXECUTED else *internal = _Addresses_Add_offset( the_port->internal_base, 1108e7: 03 51 10 add 0x10(%ecx),%edx <== NOT EXECUTED 1108ea: 89 13 mov %edx,(%ebx) <== NOT EXECUTED ending ); _Thread_Enable_dispatch(); 1108ec: e8 fb 4d 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1108f1: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1108f3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1108f6: 5b pop %ebx <== NOT EXECUTED 1108f7: 5e pop %esi <== NOT EXECUTED 1108f8: c9 leave <== NOT EXECUTED 1108f9: c3 ret <== NOT EXECUTED 001108fc : rtems_status_code rtems_port_ident( rtems_name name, Objects_Id *id ) { 1108fc: 55 push %ebp <== NOT EXECUTED 1108fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 110902: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 110905: 6a 00 push $0x0 <== NOT EXECUTED 110907: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11090a: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11090f: e8 60 47 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 110914: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_ALL_NODES, id ); return _Status_Object_name_errors_to_status[ status ]; } 11091b: c9 leave <== NOT EXECUTED 11091c: c3 ret <== NOT EXECUTED 00110920 : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 110920: 55 push %ebp <== NOT EXECUTED 110921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110923: 56 push %esi <== NOT EXECUTED 110924: 53 push %ebx <== NOT EXECUTED 110925: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 110928: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11092b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 11092e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110933: 85 db test %ebx,%ebx <== NOT EXECUTED 110935: 74 3c je 110973 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 110937: 50 push %eax <== NOT EXECUTED 110938: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11093b: 50 push %eax <== NOT EXECUTED 11093c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11093f: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 110944: e8 e3 45 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110949: 89 c1 mov %eax,%ecx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 11094b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11094e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110953: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 110957: 75 1a jne 110973 <== 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 */ 110959: 89 f2 mov %esi,%edx <== NOT EXECUTED 11095b: 2b 51 10 sub 0x10(%ecx),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 11095e: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 110961: 76 04 jbe 110967 <== NOT EXECUTED *external = internal; 110963: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 110965: eb 05 jmp 11096c <== NOT EXECUTED else *external = _Addresses_Add_offset( the_port->external_base, 110967: 03 51 14 add 0x14(%ecx),%edx <== NOT EXECUTED 11096a: 89 13 mov %edx,(%ebx) <== NOT EXECUTED ending ); _Thread_Enable_dispatch(); 11096c: e8 7b 4d 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110971: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110973: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 110976: 5b pop %ebx <== NOT EXECUTED 110977: 5e pop %esi <== NOT EXECUTED 110978: c9 leave <== NOT EXECUTED 110979: c3 ret <== NOT EXECUTED 001112e4 : */ rtems_status_code rtems_rate_monotonic_cancel( Objects_Id id ) { 1112e4: 55 push %ebp <== NOT EXECUTED 1112e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1112e7: 53 push %ebx <== NOT EXECUTED 1112e8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 1112eb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1112ee: 50 push %eax <== NOT EXECUTED 1112ef: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1112f2: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 1112f7: e8 30 3c 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1112fc: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1112fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111301: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111306: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11130a: 75 34 jne 111340 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 11130c: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 11130f: 3b 05 a0 28 13 00 cmp 0x1328a0,%eax <== NOT EXECUTED 111315: 74 0c je 111323 <== NOT EXECUTED _Thread_Enable_dispatch(); 111317: e8 d0 43 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11131c: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 111321: eb 1d jmp 111340 <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 111323: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111326: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 111329: 50 push %eax <== NOT EXECUTED 11132a: e8 f1 55 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 11132f: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 111336: e8 b1 43 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11133b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11133d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111340: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111343: c9 leave <== NOT EXECUTED 111344: c3 ret <== NOT EXECUTED 00109cb8 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 109cb8: 55 push %ebp <== NOT EXECUTED 109cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cbb: 57 push %edi <== NOT EXECUTED 109cbc: 56 push %esi <== NOT EXECUTED 109cbd: 53 push %ebx <== NOT EXECUTED 109cbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cc1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 109cc4: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109cc9: 85 f6 test %esi,%esi <== NOT EXECUTED 109ccb: 0f 84 ac 00 00 00 je 109d7d <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 109cd1: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109cd6: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 109cda: 0f 84 9d 00 00 00 je 109d7d <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109ce0: a1 c4 0a 12 00 mov 0x120ac4,%eax <== NOT EXECUTED 109ce5: 40 inc %eax <== NOT EXECUTED 109ce6: a3 c4 0a 12 00 mov %eax,0x120ac4 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cee: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109cf3: e8 e4 1a 00 00 call 10b7dc <_Objects_Allocate> <== NOT EXECUTED 109cf8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 109cfa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109cfd: 85 c0 test %eax,%eax <== NOT EXECUTED 109cff: 75 0c jne 109d0d <== NOT EXECUTED _Thread_Enable_dispatch(); 109d01: e8 b2 27 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109d06: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 109d0b: eb 70 jmp 109d7d <== NOT EXECUTED return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 109d0d: a1 84 0b 12 00 mov 0x120b84,%eax <== NOT EXECUTED 109d12: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 109d15: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109d1c: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109d23: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109d2a: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 109d31: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 109d38: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 109d3b: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 109d40: 31 c0 xor %eax,%eax <== NOT EXECUTED 109d42: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 109d44: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) <== NOT EXECUTED 109d4b: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) <== NOT EXECUTED 109d52: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) <== NOT EXECUTED 109d59: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) <== NOT EXECUTED 109d60: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 109d63: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 109d66: a1 e8 09 12 00 mov 0x1209e8,%eax <== NOT EXECUTED 109d6b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109d6e: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 109d71: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109d74: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 109d76: e8 3d 27 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109d7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109d7d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109d80: 5b pop %ebx <== NOT EXECUTED 109d81: 5e pop %esi <== NOT EXECUTED 109d82: 5f pop %edi <== NOT EXECUTED 109d83: c9 leave <== NOT EXECUTED 109d84: c3 ret <== NOT EXECUTED 00111418 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 111418: 55 push %ebp <== NOT EXECUTED 111419: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11141b: 53 push %ebx <== NOT EXECUTED 11141c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 11141f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111422: 50 push %eax <== NOT EXECUTED 111423: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111426: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 11142b: e8 fc 3a 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 111430: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 111432: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111435: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11143a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11143e: 75 36 jne 111476 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); 111440: 51 push %ecx <== NOT EXECUTED 111441: 51 push %ecx <== NOT EXECUTED 111442: 53 push %ebx <== NOT EXECUTED 111443: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 111448: e8 d3 36 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_period->Timer ); 11144d: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 111450: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 111453: e8 c8 54 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 111458: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. 11145f: 58 pop %eax <== NOT EXECUTED 111460: 5a pop %edx <== NOT EXECUTED 111461: 53 push %ebx <== NOT EXECUTED 111462: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 111467: e8 50 39 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 11146c: e8 7b 42 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111471: 31 c0 xor %eax,%eax <== NOT EXECUTED 111473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111476: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111479: c9 leave <== NOT EXECUTED 11147a: c3 ret <== NOT EXECUTED 001294a4 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 1294a4: 55 push %ebp <== NOT EXECUTED 1294a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1294a7: 57 push %edi <== NOT EXECUTED 1294a8: 56 push %esi <== NOT EXECUTED 1294a9: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 1294ac: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 1294af: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1294b4: 85 ff test %edi,%edi <== NOT EXECUTED 1294b6: 74 33 je 1294eb <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 1294b8: 50 push %eax <== NOT EXECUTED 1294b9: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1294bc: 50 push %eax <== NOT EXECUTED 1294bd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1294c0: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 1294c5: e8 06 5c fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 1294ca: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1294cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1294cf: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1294d4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1294d8: 75 11 jne 1294eb <== NOT EXECUTED case OBJECTS_LOCAL: *statistics = the_period->Statistics; 1294da: 8d 72 54 lea 0x54(%edx),%esi <== NOT EXECUTED 1294dd: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 1294e2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1294e4: e8 57 64 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1294e9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1294eb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1294ee: 5e pop %esi <== NOT EXECUTED 1294ef: 5f pop %edi <== NOT EXECUTED 1294f0: c9 leave <== NOT EXECUTED 1294f1: c3 ret <== NOT EXECUTED 001294f4 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 1294f4: 55 push %ebp <== NOT EXECUTED 1294f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1294f7: 57 push %edi <== NOT EXECUTED 1294f8: 56 push %esi <== NOT EXECUTED 1294f9: 53 push %ebx <== NOT EXECUTED 1294fa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1294fd: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 129500: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 129505: 85 f6 test %esi,%esi <== NOT EXECUTED 129507: 0f 84 91 00 00 00 je 12959e <== NOT EXECUTED 12950d: 50 push %eax <== NOT EXECUTED 12950e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 129511: 50 push %eax <== NOT EXECUTED 129512: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129515: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 12951a: e8 b1 5b fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 12951f: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 129521: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129524: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 129529: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 12952d: 75 6f jne 12959e <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12952f: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 129532: 31 d2 xor %edx,%edx <== NOT EXECUTED 129534: 85 c0 test %eax,%eax <== NOT EXECUTED 129536: 74 03 je 12953b <== NOT EXECUTED 129538: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 12953b: 89 16 mov %edx,(%esi) <== NOT EXECUTED status->state = the_period->state; 12953d: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 129540: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 129543: 85 c0 test %eax,%eax <== NOT EXECUTED 129545: 75 1e jne 129565 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 129547: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12954e: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 129555: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12955c: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED 129563: eb 32 jmp 129597 <== 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 ); 129565: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129568: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 12956b: 53 push %ebx <== NOT EXECUTED 12956c: e8 6f 83 ff ff call 1218e0 <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 129571: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129574: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 129577: 50 push %eax <== NOT EXECUTED 129578: 53 push %ebx <== NOT EXECUTED 129579: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 12957c: 50 push %eax <== NOT EXECUTED 12957d: e8 16 6f fe ff call 110498 <_Timespec_Subtract> <== NOT EXECUTED status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 129582: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129585: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 129588: 50 push %eax <== NOT EXECUTED 129589: 53 push %ebx <== NOT EXECUTED 12958a: 68 bc 9c 15 00 push $0x159cbc <== NOT EXECUTED 12958f: e8 04 6f fe ff call 110498 <_Timespec_Subtract> <== NOT EXECUTED 129594: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 129597: e8 a4 63 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 12959c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12959e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1295a1: 5b pop %ebx <== NOT EXECUTED 1295a2: 5e pop %esi <== NOT EXECUTED 1295a3: 5f pop %edi <== NOT EXECUTED 1295a4: c9 leave <== NOT EXECUTED 1295a5: c3 ret <== NOT EXECUTED 00109d88 : rtems_status_code rtems_rate_monotonic_ident( rtems_name name, Objects_Id *id ) { 109d88: 55 push %ebp <== NOT EXECUTED 109d89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d8b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 109d8e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109d91: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 109d96: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d99: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109d9e: e8 9d 20 00 00 call 10be40 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109da3: 8b 04 85 fc 9c 11 00 mov 0x119cfc(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 109daa: c9 leave <== NOT EXECUTED 109dab: c3 ret <== NOT EXECUTED 00109f52 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 109f52: 55 push %ebp <== NOT EXECUTED 109f53: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f55: 57 push %edi <== NOT EXECUTED 109f56: 56 push %esi <== NOT EXECUTED 109f57: 53 push %ebx <== NOT EXECUTED 109f58: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 109f5b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 109f5e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109f61: 50 push %eax <== NOT EXECUTED 109f62: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109f65: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109f6a: e8 89 1d 00 00 call 10bcf8 <_Objects_Get> <== NOT EXECUTED 109f6f: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 109f71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f74: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109f78: 0f 85 44 01 00 00 jne 10a0c2 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 109f7e: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 109f81: 3b 05 84 0b 12 00 cmp 0x120b84,%eax <== NOT EXECUTED 109f87: 74 0f je 109f98 <== NOT EXECUTED _Thread_Enable_dispatch(); 109f89: e8 2a 25 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109f8e: bb 17 00 00 00 mov $0x17,%ebx <== NOT EXECUTED 109f93: e9 2f 01 00 00 jmp 10a0c7 <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 109f98: 85 ff test %edi,%edi <== NOT EXECUTED 109f9a: 75 21 jne 109fbd <== NOT EXECUTED switch ( the_period->state ) { 109f9c: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 109f9f: bb 0b 00 00 00 mov $0xb,%ebx <== NOT EXECUTED 109fa4: 85 c0 test %eax,%eax <== NOT EXECUTED 109fa6: 74 0b je 109fb3 <== NOT EXECUTED 109fa8: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 109fab: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fae: 19 db sbb %ebx,%ebx <== NOT EXECUTED 109fb0: 83 e3 06 and $0x6,%ebx <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 109fb3: e8 00 25 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109fb8: e9 0a 01 00 00 jmp 10a0c7 <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); 109fbd: 9c pushf <== NOT EXECUTED 109fbe: fa cli <== NOT EXECUTED 109fbf: 5e pop %esi <== NOT EXECUTED switch ( the_period->state ) { 109fc0: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 109fc3: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fc6: 74 60 je 10a028 <== NOT EXECUTED 109fc8: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109fcb: 0f 84 ba 00 00 00 je 10a08b <== NOT EXECUTED 109fd1: 85 c0 test %eax,%eax <== NOT EXECUTED 109fd3: 0f 85 e9 00 00 00 jne 10a0c2 <== NOT EXECUTED case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 109fd9: 56 push %esi <== NOT EXECUTED 109fda: 9d popf <== NOT EXECUTED /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 109fdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fde: 53 push %ebx <== NOT EXECUTED 109fdf: e8 c8 fd ff ff call 109dac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 109fe4: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109feb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109ff2: c7 43 2c e8 a2 10 00 movl $0x10a2e8,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109ff9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ffc: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 109fff: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10a006: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a009: 89 7b 1c mov %edi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a00c: 58 pop %eax <== NOT EXECUTED 10a00d: 5a pop %edx <== NOT EXECUTED 10a00e: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a011: 50 push %eax <== NOT EXECUTED 10a012: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a017: e8 f8 33 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a01c: e8 97 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a021: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a023: e9 95 00 00 00 jmp 10a0bd <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10a028: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a02b: 53 push %ebx <== NOT EXECUTED 10a02c: e8 e3 fd ff ff call 109e14 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 10a031: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10a038: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a03b: 56 push %esi <== NOT EXECUTED 10a03c: 9d popf <== NOT EXECUTED _Thread_Executing->Wait.id = the_period->Object.id; 10a03d: 8b 15 84 0b 12 00 mov 0x120b84,%edx <== NOT EXECUTED 10a043: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a046: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a049: 5e pop %esi <== NOT EXECUTED 10a04a: 5f pop %edi <== NOT EXECUTED 10a04b: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10a050: 52 push %edx <== NOT EXECUTED 10a051: e8 7e 2c 00 00 call 10ccd4 <_Thread_Set_state> <== NOT EXECUTED /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10a056: 9c pushf <== NOT EXECUTED 10a057: fa cli <== NOT EXECUTED 10a058: 58 pop %eax <== NOT EXECUTED local_state = the_period->state; 10a059: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10a05c: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a063: 50 push %eax <== NOT EXECUTED 10a064: 9d popf <== NOT EXECUTED /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 10a065: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a068: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10a06b: 75 15 jne 10a082 <== NOT EXECUTED _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a06d: 51 push %ecx <== NOT EXECUTED 10a06e: 51 push %ecx <== NOT EXECUTED 10a06f: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10a074: ff 35 84 0b 12 00 pushl 0x120b84 <== NOT EXECUTED 10a07a: e8 b9 20 00 00 call 10c138 <_Thread_Clear_state> <== NOT EXECUTED 10a07f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 10a082: e8 31 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a087: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a089: eb 3c jmp 10a0c7 <== NOT EXECUTED case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10a08b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a08e: 53 push %ebx <== NOT EXECUTED 10a08f: e8 80 fd ff ff call 109e14 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED _ISR_Enable( level ); 10a094: 56 push %esi <== NOT EXECUTED 10a095: 9d popf <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10a096: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10a09d: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a0a0: 89 7b 1c mov %edi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a0a3: 58 pop %eax <== NOT EXECUTED 10a0a4: 5a pop %edx <== NOT EXECUTED 10a0a5: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a0a8: 50 push %eax <== NOT EXECUTED 10a0a9: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a0ae: e8 61 33 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a0b3: e8 00 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a0b8: bb 06 00 00 00 mov $0x6,%ebx <== NOT EXECUTED 10a0bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c0: eb 05 jmp 10a0c7 <== NOT EXECUTED return RTEMS_TIMEOUT; 10a0c2: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a0c7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a0c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0cc: 5b pop %ebx <== NOT EXECUTED 10a0cd: 5e pop %esi <== NOT EXECUTED 10a0ce: 5f pop %edi <== NOT EXECUTED 10a0cf: c9 leave <== NOT EXECUTED 10a0d0: c3 ret <== NOT EXECUTED 00120f78 : void rtems_rate_monotonic_report_statistics( void ) { 120f78: 55 push %ebp <== NOT EXECUTED 120f79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120f7b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 120f7e: 68 e4 b1 10 00 push $0x10b1e4 <== NOT EXECUTED 120f83: 6a 00 push $0x0 <== NOT EXECUTED 120f85: e8 8e fe ff ff call 120e18 <== NOT EXECUTED 120f8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 120f8d: c9 leave <== NOT EXECUTED 120f8e: c3 ret <== NOT EXECUTED 00120e18 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 120e18: 55 push %ebp <== NOT EXECUTED 120e19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120e1b: 57 push %edi <== NOT EXECUTED 120e1c: 56 push %esi <== NOT EXECUTED 120e1d: 53 push %ebx <== NOT EXECUTED 120e1e: 83 ec 6c sub $0x6c,%esp <== NOT EXECUTED 120e21: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 120e24: 85 f6 test %esi,%esi <== NOT EXECUTED 120e26: 0f 84 44 01 00 00 je 120f70 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 120e2c: 51 push %ecx <== NOT EXECUTED 120e2d: 51 push %ecx <== NOT EXECUTED 120e2e: 68 35 d0 13 00 push $0x13d035 <== NOT EXECUTED 120e33: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e36: ff d6 call *%esi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 120e38: 58 pop %eax <== NOT EXECUTED 120e39: 5a pop %edx <== NOT EXECUTED 120e3a: 68 53 d0 13 00 push $0x13d053 <== NOT EXECUTED 120e3f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e42: ff d6 call *%esi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 120e44: 5f pop %edi <== NOT EXECUTED 120e45: 58 pop %eax <== NOT EXECUTED 120e46: 68 75 d0 13 00 push $0x13d075 <== NOT EXECUTED 120e4b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e4e: ff d6 call *%esi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 120e50: 59 pop %ecx <== NOT EXECUTED 120e51: 5b pop %ebx <== NOT EXECUTED 120e52: 68 98 d0 13 00 push $0x13d098 <== NOT EXECUTED 120e57: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e5a: ff d6 call *%esi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 120e5c: 58 pop %eax <== NOT EXECUTED 120e5d: 5a pop %edx <== NOT EXECUTED 120e5e: 68 e3 d0 13 00 push $0x13d0e3 <== NOT EXECUTED 120e63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e66: ff d6 call *%esi <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 120e68: 8b 3d 5c a1 15 00 mov 0x15a15c,%edi <== NOT EXECUTED 120e6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120e71: e9 ee 00 00 00 jmp 120f64 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 120e76: 50 push %eax <== NOT EXECUTED 120e77: 50 push %eax <== NOT EXECUTED 120e78: 8d 45 94 lea -0x6c(%ebp),%eax <== NOT EXECUTED 120e7b: 50 push %eax <== NOT EXECUTED 120e7c: 57 push %edi <== NOT EXECUTED 120e7d: e8 22 86 00 00 call 1294a4 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 120e82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120e85: 85 c0 test %eax,%eax <== NOT EXECUTED 120e87: 0f 85 d6 00 00 00 jne 120f63 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 120e8d: 50 push %eax <== NOT EXECUTED 120e8e: 50 push %eax <== NOT EXECUTED 120e8f: 8d 55 cc lea -0x34(%ebp),%edx <== NOT EXECUTED 120e92: 52 push %edx <== NOT EXECUTED 120e93: 57 push %edi <== NOT EXECUTED 120e94: e8 5b 86 00 00 call 1294f4 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 120e99: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 120e9d: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED 120ea0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ea3: 85 d2 test %edx,%edx <== NOT EXECUTED 120ea5: 74 10 je 120eb7 <== NOT EXECUTED rtems_object_get_name( the_status.owner, sizeof(name), name ); 120ea7: 50 push %eax <== NOT EXECUTED 120ea8: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 120eab: 50 push %eax <== NOT EXECUTED 120eac: 6a 05 push $0x5 <== NOT EXECUTED 120eae: 52 push %edx <== NOT EXECUTED 120eaf: e8 ac c7 fe ff call 10d660 <== NOT EXECUTED 120eb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 120eb7: 53 push %ebx <== NOT EXECUTED 120eb8: 53 push %ebx <== NOT EXECUTED 120eb9: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 120ebc: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 120ebf: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 120ec2: 50 push %eax <== NOT EXECUTED 120ec3: 57 push %edi <== NOT EXECUTED 120ec4: 68 2f d1 13 00 push $0x13d12f <== NOT EXECUTED 120ec9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120ecc: ff d6 call *%esi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 120ece: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED 120ed1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 120ed4: 85 c0 test %eax,%eax <== NOT EXECUTED 120ed6: 75 11 jne 120ee9 <== NOT EXECUTED (*print)( context, "\n" ); 120ed8: 51 push %ecx <== NOT EXECUTED 120ed9: 51 push %ecx <== NOT EXECUTED 120eda: 68 65 d4 13 00 push $0x13d465 <== NOT EXECUTED 120edf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120ee2: ff d6 call *%esi <== NOT EXECUTED 120ee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ee7: eb 7a jmp 120f63 <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 120ee9: 52 push %edx <== NOT EXECUTED 120eea: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 120eed: 52 push %edx <== NOT EXECUTED 120eee: 50 push %eax <== NOT EXECUTED 120eef: 8d 45 ac lea -0x54(%ebp),%eax <== NOT EXECUTED 120ef2: 50 push %eax <== NOT EXECUTED 120ef3: e8 10 13 00 00 call 122208 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 120ef8: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120efb: bb e8 03 00 00 mov $0x3e8,%ebx <== NOT EXECUTED 120f00: 99 cltd <== NOT EXECUTED 120f01: f7 fb idiv %ebx <== NOT EXECUTED 120f03: 50 push %eax <== NOT EXECUTED 120f04: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 120f07: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 120f0a: 99 cltd <== NOT EXECUTED 120f0b: f7 fb idiv %ebx <== NOT EXECUTED 120f0d: 50 push %eax <== NOT EXECUTED 120f0e: ff 75 a4 pushl -0x5c(%ebp) <== NOT EXECUTED 120f11: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 120f14: 99 cltd <== NOT EXECUTED 120f15: f7 fb idiv %ebx <== NOT EXECUTED 120f17: 50 push %eax <== NOT EXECUTED 120f18: ff 75 9c pushl -0x64(%ebp) <== NOT EXECUTED 120f1b: 68 46 d1 13 00 push $0x13d146 <== NOT EXECUTED 120f20: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120f23: ff d6 call *%esi <== NOT EXECUTED * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 120f25: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 120f28: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 120f2b: 50 push %eax <== NOT EXECUTED 120f2c: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 120f2f: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 120f32: 50 push %eax <== NOT EXECUTED 120f33: e8 d0 12 00 00 call 122208 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 120f38: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120f3b: 99 cltd <== NOT EXECUTED 120f3c: f7 fb idiv %ebx <== NOT EXECUTED 120f3e: 50 push %eax <== NOT EXECUTED 120f3f: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 120f42: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 120f45: 99 cltd <== NOT EXECUTED 120f46: f7 fb idiv %ebx <== NOT EXECUTED 120f48: 50 push %eax <== NOT EXECUTED 120f49: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 120f4c: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED 120f4f: 99 cltd <== NOT EXECUTED 120f50: f7 fb idiv %ebx <== NOT EXECUTED 120f52: 50 push %eax <== NOT EXECUTED 120f53: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 120f56: 68 65 d1 13 00 push $0x13d165 <== NOT EXECUTED 120f5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120f5e: ff d6 call *%esi <== NOT EXECUTED 120f60: 83 c4 30 add $0x30,%esp <== NOT EXECUTED * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 120f63: 47 inc %edi <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 120f64: 3b 3d 60 a1 15 00 cmp 0x15a160,%edi <== NOT EXECUTED 120f6a: 0f 86 06 ff ff ff jbe 120e76 <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 120f70: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120f73: 5b pop %ebx <== NOT EXECUTED 120f74: 5e pop %esi <== NOT EXECUTED 120f75: 5f pop %edi <== NOT EXECUTED 120f76: c9 leave <== NOT EXECUTED 120f77: c3 ret <== NOT EXECUTED 00120f90 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 120f90: 55 push %ebp <== NOT EXECUTED 120f91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120f93: 53 push %ebx <== NOT EXECUTED 120f94: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 120f97: a1 f4 9b 15 00 mov 0x159bf4,%eax <== NOT EXECUTED 120f9c: 40 inc %eax <== NOT EXECUTED 120f9d: a3 f4 9b 15 00 mov %eax,0x159bf4 <== NOT EXECUTED /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 120fa2: 8b 1d 5c a1 15 00 mov 0x15a15c,%ebx <== NOT EXECUTED 120fa8: eb 0d jmp 120fb7 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 120faa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120fad: 53 push %ebx <== NOT EXECUTED 120fae: e8 15 00 00 00 call 120fc8 <== NOT EXECUTED * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 120fb3: 43 inc %ebx <== NOT EXECUTED 120fb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 120fb7: 3b 1d 60 a1 15 00 cmp 0x15a160,%ebx <== NOT EXECUTED 120fbd: 76 eb jbe 120faa <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 120fbf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120fc2: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 120fc3: e9 78 e9 fe ff jmp 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 00120fc8 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 120fc8: 55 push %ebp <== NOT EXECUTED 120fc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120fcb: 57 push %edi <== NOT EXECUTED 120fcc: 56 push %esi <== NOT EXECUTED 120fcd: 53 push %ebx <== NOT EXECUTED 120fce: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 120fd1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 120fd4: 50 push %eax <== NOT EXECUTED 120fd5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120fd8: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 120fdd: e8 ee e0 fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 120fe2: 89 c6 mov %eax,%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 120fe4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120fe7: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 120fea: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 120fef: 85 db test %ebx,%ebx <== NOT EXECUTED 120ff1: 75 2f jne 121022 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 120ff3: 8d 78 54 lea 0x54(%eax),%edi <== NOT EXECUTED 120ff6: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 120ffb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120ffd: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 120fff: c7 46 5c ff ff ff 7f movl $0x7fffffff,0x5c(%esi) <== NOT EXECUTED 121006: c7 46 60 ff ff ff 7f movl $0x7fffffff,0x60(%esi) <== NOT EXECUTED 12100d: c7 46 74 ff ff ff 7f movl $0x7fffffff,0x74(%esi) <== NOT EXECUTED 121014: c7 46 78 ff ff ff 7f movl $0x7fffffff,0x78(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12101b: e8 20 e9 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 121020: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121022: 89 d0 mov %edx,%eax <== NOT EXECUTED 121024: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121027: 5b pop %ebx <== NOT EXECUTED 121028: 5e pop %esi <== NOT EXECUTED 121029: 5f pop %edi <== NOT EXECUTED 12102a: c9 leave <== NOT EXECUTED 12102b: c3 ret <== NOT EXECUTED 00111908 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 111908: 55 push %ebp <== NOT EXECUTED 111909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11190b: 57 push %edi <== NOT EXECUTED 11190c: 56 push %esi <== NOT EXECUTED 11190d: 53 push %ebx <== NOT EXECUTED 11190e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111911: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 111914: be 03 00 00 00 mov $0x3,%esi <== NOT EXECUTED 111919: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11191d: 0f 84 dc 00 00 00 je 1119ff <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 111923: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 111927: 0f 84 cd 00 00 00 je 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 11192d: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 111931: 0f 84 c3 00 00 00 je 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 111937: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 11193b: 0f 85 b9 00 00 00 jne 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 111941: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111944: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 11194a: e8 f5 1f 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11194f: c7 04 24 94 26 13 00 movl $0x132694,(%esp) <== NOT EXECUTED 111956: e8 51 31 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 11195b: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Allocate(); if ( !the_region ) 11195d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111960: be 05 00 00 00 mov $0x5,%esi <== NOT EXECUTED 111965: 85 c0 test %eax,%eax <== NOT EXECUTED 111967: 74 7e je 1119e7 <== NOT EXECUTED return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 111969: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11196c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11196f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111972: 8d 40 68 lea 0x68(%eax),%eax <== NOT EXECUTED 111975: 50 push %eax <== NOT EXECUTED 111976: e8 75 2c 00 00 call 1145f0 <_Heap_Initialize> <== NOT EXECUTED 11197b: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 11197e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111981: 85 c0 test %eax,%eax <== NOT EXECUTED 111983: 75 14 jne 111999 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 111985: 50 push %eax <== NOT EXECUTED 111986: 50 push %eax <== NOT EXECUTED 111987: 53 push %ebx <== NOT EXECUTED 111988: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 11198d: e8 2a 34 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 111992: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED 111997: eb 4b jmp 1119e4 <== NOT EXECUTED return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 111999: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11199c: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_region->length = length; 11199f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1119a2: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED the_region->page_size = page_size; 1119a5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1119a8: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED the_region->attribute_set = attribute_set; 1119ab: 89 7b 60 mov %edi,0x60(%ebx) <== NOT EXECUTED the_region->number_of_used_blocks = 0; 1119ae: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED _Thread_queue_Initialize( 1119b5: 6a 06 push $0x6 <== NOT EXECUTED 1119b7: 6a 40 push $0x40 <== NOT EXECUTED 1119b9: c1 ef 02 shr $0x2,%edi <== NOT EXECUTED 1119bc: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 1119bf: 57 push %edi <== NOT EXECUTED 1119c0: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 1119c3: 50 push %eax <== NOT EXECUTED 1119c4: e8 a7 43 00 00 call 115d70 <_Thread_queue_Initialize> <== NOT EXECUTED 1119c9: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1119cc: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1119cf: a1 b0 26 13 00 mov 0x1326b0,%eax <== NOT EXECUTED 1119d4: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1119d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1119da: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1119dd: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1119e0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1119e2: 31 f6 xor %esi,%esi <== NOT EXECUTED 1119e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 1119e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1119ea: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 1119f0: e8 97 1f 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 1119f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1119f8: eb 05 jmp 1119ff <== NOT EXECUTED return return_status; 1119fa: be 09 00 00 00 mov $0x9,%esi <== NOT EXECUTED } 1119ff: 89 f0 mov %esi,%eax <== NOT EXECUTED 111a01: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111a04: 5b pop %ebx <== NOT EXECUTED 111a05: 5e pop %esi <== NOT EXECUTED 111a06: 5f pop %edi <== NOT EXECUTED 111a07: c9 leave <== NOT EXECUTED 111a08: c3 ret <== NOT EXECUTED 00111a0c : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 111a0c: 55 push %ebp <== NOT EXECUTED 111a0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111a0f: 56 push %esi <== NOT EXECUTED 111a10: 53 push %ebx <== NOT EXECUTED 111a11: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; _RTEMS_Lock_allocator(); 111a14: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111a1a: e8 25 1f 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111a1f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111a22: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111a25: 50 push %eax <== NOT EXECUTED 111a26: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111a29: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a2e: e8 bd 34 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111a33: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111a35: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111a38: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 111a3b: 85 c0 test %eax,%eax <== NOT EXECUTED 111a3d: 74 11 je 111a50 <== NOT EXECUTED 111a3f: 31 db xor %ebx,%ebx <== NOT EXECUTED 111a41: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111a44: 0f 95 c3 setne %bl <== NOT EXECUTED 111a47: 4b dec %ebx <== NOT EXECUTED 111a48: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111a4b: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111a4e: eb 2a jmp 111a7a <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 111a50: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 111a55: 83 7e 64 00 cmpl $0x0,0x64(%esi) <== NOT EXECUTED 111a59: 75 1f jne 111a7a <== NOT EXECUTED return_status = RTEMS_RESOURCE_IN_USE; else { _Objects_Close( &_Region_Information, &the_region->Object ); 111a5b: 51 push %ecx <== NOT EXECUTED 111a5c: 51 push %ecx <== NOT EXECUTED 111a5d: 56 push %esi <== NOT EXECUTED 111a5e: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a63: e8 b8 30 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 111a68: 58 pop %eax <== NOT EXECUTED 111a69: 5a pop %edx <== NOT EXECUTED 111a6a: 56 push %esi <== NOT EXECUTED 111a6b: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a70: e8 47 33 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 111a75: 31 db xor %ebx,%ebx <== NOT EXECUTED 111a77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111a7a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111a7d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111a83: e8 04 1f 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 111a88: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111a8a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111a8d: 5b pop %ebx <== NOT EXECUTED 111a8e: 5e pop %esi <== NOT EXECUTED 111a8f: c9 leave <== NOT EXECUTED 111a90: c3 ret <== NOT EXECUTED 00111a94 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 111a94: 55 push %ebp <== NOT EXECUTED 111a95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111a97: 57 push %edi <== NOT EXECUTED 111a98: 56 push %esi <== NOT EXECUTED 111a99: 53 push %ebx <== NOT EXECUTED 111a9a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111a9d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 111aa0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111aa5: 85 ff test %edi,%edi <== NOT EXECUTED 111aa7: 0f 84 82 00 00 00 je 111b2f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 111aad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111ab0: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111ab6: e8 89 1e 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111abb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111abe: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 111ac1: 50 push %eax <== NOT EXECUTED 111ac2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ac5: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111aca: e8 21 34 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111acf: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111ad1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ad4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111ad7: 85 c0 test %eax,%eax <== NOT EXECUTED 111ad9: 74 08 je 111ae3 <== NOT EXECUTED 111adb: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 111ae0: 48 dec %eax <== NOT EXECUTED 111ae1: eb 25 jmp 111b08 <== NOT EXECUTED case OBJECTS_LOCAL: heap_status = _Heap_Extend( 111ae3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111ae6: 50 push %eax <== NOT EXECUTED 111ae7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 111aea: 57 push %edi <== NOT EXECUTED 111aeb: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111aee: 50 push %eax <== NOT EXECUTED 111aef: e8 4c 28 00 00 call 114340 <_Heap_Extend> <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 111af4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111af7: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111afc: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111aff: 74 1d je 111b1e <== NOT EXECUTED 111b01: 72 09 jb 111b0c <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 111b03: b3 18 mov $0x18,%bl <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 111b05: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 111b08: 75 0f jne 111b19 <== NOT EXECUTED 111b0a: eb 12 jmp 111b1e <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 111b0c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 111b0f: 01 46 54 add %eax,0x54(%esi) <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 111b12: 01 46 5c add %eax,0x5c(%esi) <== NOT EXECUTED 111b15: 31 db xor %ebx,%ebx <== NOT EXECUTED 111b17: eb 05 jmp 111b1e <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; break; 111b19: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111b1e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b21: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111b27: e8 60 1e 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111b2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111b2f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111b31: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111b34: 5b pop %ebx <== NOT EXECUTED 111b35: 5e pop %esi <== NOT EXECUTED 111b36: 5f pop %edi <== NOT EXECUTED 111b37: c9 leave <== NOT EXECUTED 111b38: c3 ret <== NOT EXECUTED 00111b3c : rtems_status_code rtems_region_get_free_information( Objects_Id id, Heap_Information_block *the_info ) { 111b3c: 55 push %ebp <== NOT EXECUTED 111b3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111b3f: 56 push %esi <== NOT EXECUTED 111b40: 53 push %ebx <== NOT EXECUTED 111b41: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111b44: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 111b47: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111b4c: 85 f6 test %esi,%esi <== NOT EXECUTED 111b4e: 74 74 je 111bc4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111b50: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b53: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111b59: e8 e6 1d 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111b5e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111b61: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111b64: 50 push %eax <== NOT EXECUTED 111b65: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111b68: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111b6d: e8 7e 33 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b75: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111b78: 85 d2 test %edx,%edx <== NOT EXECUTED 111b7a: 74 11 je 111b8d <== NOT EXECUTED 111b7c: 31 db xor %ebx,%ebx <== NOT EXECUTED 111b7e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111b81: 0f 95 c3 setne %bl <== NOT EXECUTED 111b84: 4b dec %ebx <== NOT EXECUTED 111b85: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111b88: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111b8b: eb 26 jmp 111bb3 <== NOT EXECUTED case OBJECTS_LOCAL: the_info->Used.number = 0; 111b8d: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED the_info->Used.total = 0; 111b94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED the_info->Used.largest = 0; 111b9b: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 111ba2: 52 push %edx <== NOT EXECUTED 111ba3: 52 push %edx <== NOT EXECUTED 111ba4: 56 push %esi <== NOT EXECUTED 111ba5: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111ba8: 50 push %eax <== NOT EXECUTED 111ba9: e8 82 29 00 00 call 114530 <_Heap_Get_free_information> <== NOT EXECUTED 111bae: 31 db xor %ebx,%ebx <== NOT EXECUTED 111bb0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111bb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111bb6: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111bbc: e8 cb 1d 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111bc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111bc4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111bc6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111bc9: 5b pop %ebx <== NOT EXECUTED 111bca: 5e pop %esi <== NOT EXECUTED 111bcb: c9 leave <== NOT EXECUTED 111bcc: c3 ret <== NOT EXECUTED 00111bd0 : rtems_status_code rtems_region_get_information( Objects_Id id, Heap_Information_block *the_info ) { 111bd0: 55 push %ebp <== NOT EXECUTED 111bd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111bd3: 56 push %esi <== NOT EXECUTED 111bd4: 53 push %ebx <== NOT EXECUTED 111bd5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111bd8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 111bdb: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111be0: 85 f6 test %esi,%esi <== NOT EXECUTED 111be2: 74 67 je 111c4b <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111be4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111be7: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111bed: e8 52 1d 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111bf2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111bf5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111bf8: 50 push %eax <== NOT EXECUTED 111bf9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111bfc: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111c01: e8 ea 32 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111c06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111c09: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111c0c: 85 d2 test %edx,%edx <== NOT EXECUTED 111c0e: 74 11 je 111c21 <== NOT EXECUTED 111c10: 31 db xor %ebx,%ebx <== NOT EXECUTED 111c12: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111c15: 0f 95 c3 setne %bl <== NOT EXECUTED 111c18: 4b dec %ebx <== NOT EXECUTED 111c19: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111c1c: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111c1f: eb 19 jmp 111c3a <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Heap_Get_information( &the_region->Memory, the_info ) != 111c21: 52 push %edx <== NOT EXECUTED 111c22: 52 push %edx <== NOT EXECUTED 111c23: 56 push %esi <== NOT EXECUTED 111c24: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111c27: 50 push %eax <== NOT EXECUTED 111c28: e8 43 29 00 00 call 114570 <_Heap_Get_information> <== NOT EXECUTED 111c2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111c30: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111c33: 19 db sbb %ebx,%ebx <== NOT EXECUTED 111c35: f7 d3 not %ebx <== NOT EXECUTED 111c37: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111c3a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111c3d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111c43: e8 44 1d 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111c48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111c4b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111c4d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111c50: 5b pop %ebx <== NOT EXECUTED 111c51: 5e pop %esi <== NOT EXECUTED 111c52: c9 leave <== NOT EXECUTED 111c53: c3 ret <== NOT EXECUTED 00111c54 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 111c54: 55 push %ebp <== NOT EXECUTED 111c55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111c57: 57 push %edi <== NOT EXECUTED 111c58: 56 push %esi <== NOT EXECUTED 111c59: 53 push %ebx <== NOT EXECUTED 111c5a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 111c5d: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111c62: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 111c66: 0f 84 fd 00 00 00 je 111d69 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *segment = NULL; 111c6c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111c6f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED if ( size == 0 ) 111c75: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 111c7a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 111c7e: 0f 84 e5 00 00 00 je 111d69 <== NOT EXECUTED return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 111c84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111c87: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111c8d: e8 b2 1c 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 111c92: 8b 3d a0 28 13 00 mov 0x1328a0,%edi <== NOT EXECUTED 111c98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111c9b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111c9e: 50 push %eax <== NOT EXECUTED 111c9f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ca2: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111ca7: e8 44 32 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111cac: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111cae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111cb1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 111cb4: 85 c0 test %eax,%eax <== NOT EXECUTED 111cb6: 74 14 je 111ccc <== NOT EXECUTED 111cb8: 31 db xor %ebx,%ebx <== NOT EXECUTED 111cba: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111cbd: 0f 95 c3 setne %bl <== NOT EXECUTED 111cc0: 4b dec %ebx <== NOT EXECUTED 111cc1: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111cc4: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111cc7: e9 8c 00 00 00 jmp 111d58 <== NOT EXECUTED case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 111ccc: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 111cd1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111cd4: 3b 56 5c cmp 0x5c(%esi),%edx <== NOT EXECUTED 111cd7: 77 7f ja 111d58 <== 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. * 111cd9: 50 push %eax <== NOT EXECUTED 111cda: 50 push %eax <== NOT EXECUTED 111cdb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111cde: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111ce1: 50 push %eax <== NOT EXECUTED 111ce2: e8 ed 25 00 00 call 1142d4 <_Heap_Allocate> <== NOT EXECUTED the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 111ce7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111cea: 85 c0 test %eax,%eax <== NOT EXECUTED 111cec: 74 0c je 111cfa <== NOT EXECUTED the_region->number_of_used_blocks += 1; 111cee: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED *segment = the_segment; 111cf1: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 111cf4: 89 02 mov %eax,(%edx) <== NOT EXECUTED 111cf6: 31 db xor %ebx,%ebx <== NOT EXECUTED 111cf8: eb 5e jmp 111d58 <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 111cfa: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 111cff: f6 45 10 01 testb $0x1,0x10(%ebp) <== NOT EXECUTED 111d03: 75 53 jne 111d58 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111d05: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 111d0a: 40 inc %eax <== NOT EXECUTED 111d0b: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 111d10: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d13: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d19: e8 6e 1c 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED executing->Wait.queue = &the_region->Wait_queue; 111d1e: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 111d21: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED executing->Wait.id = id; 111d24: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 111d27: 89 57 20 mov %edx,0x20(%edi) <== NOT EXECUTED executing->Wait.count = size; 111d2a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111d2d: 89 57 24 mov %edx,0x24(%edi) <== NOT EXECUTED executing->Wait.return_argument = segment; 111d30: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 111d33: 89 57 28 mov %edx,0x28(%edi) <== 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 111d36: c7 46 40 01 00 00 00 movl $0x1,0x40(%esi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 111d3d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111d40: 68 40 5e 11 00 push $0x115e40 <== NOT EXECUTED 111d45: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 111d48: 50 push %eax <== NOT EXECUTED 111d49: e8 ee 3d 00 00 call 115b3c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 111d4e: e8 99 39 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED return (rtems_status_code) executing->Wait.return_code; 111d53: 8b 5f 34 mov 0x34(%edi),%ebx <== NOT EXECUTED 111d56: eb 0e jmp 111d66 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111d58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d5b: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d61: e8 26 1c 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111d66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111d69: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111d6b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111d6e: 5b pop %ebx <== NOT EXECUTED 111d6f: 5e pop %esi <== NOT EXECUTED 111d70: 5f pop %edi <== NOT EXECUTED 111d71: c9 leave <== NOT EXECUTED 111d72: c3 ret <== NOT EXECUTED 00111d74 : rtems_status_code rtems_region_get_segment_size( Objects_Id id, void *segment, size_t *size ) { 111d74: 55 push %ebp <== NOT EXECUTED 111d75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111d77: 56 push %esi <== NOT EXECUTED 111d78: 53 push %ebx <== NOT EXECUTED 111d79: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111d7c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 111d7f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !segment ) 111d82: 85 f6 test %esi,%esi <== NOT EXECUTED 111d84: 74 6a je 111df0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 111d86: 85 db test %ebx,%ebx <== NOT EXECUTED 111d88: 74 66 je 111df0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111d8a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d8d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d93: e8 ac 1b 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111d98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111d9b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111d9e: 50 push %eax <== NOT EXECUTED 111d9f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111da2: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111da7: e8 44 31 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111dac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111daf: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111db2: 85 d2 test %edx,%edx <== NOT EXECUTED 111db4: 74 11 je 111dc7 <== NOT EXECUTED 111db6: 31 db xor %ebx,%ebx <== NOT EXECUTED 111db8: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111dbb: 0f 95 c3 setne %bl <== NOT EXECUTED 111dbe: 4b dec %ebx <== NOT EXECUTED 111dbf: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111dc2: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111dc5: eb 16 jmp 111ddd <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) ) 111dc7: 52 push %edx <== NOT EXECUTED 111dc8: 53 push %ebx <== NOT EXECUTED 111dc9: 56 push %esi <== NOT EXECUTED 111dca: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111dcd: 50 push %eax <== NOT EXECUTED 111dce: e8 d5 2b 00 00 call 1149a8 <_Heap_Size_of_user_area> <== NOT EXECUTED 111dd3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111dd6: 3c 01 cmp $0x1,%al <== NOT EXECUTED 111dd8: 19 db sbb %ebx,%ebx <== NOT EXECUTED 111dda: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111ddd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111de0: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111de6: e8 a1 1b 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111deb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111dee: eb 05 jmp 111df5 <== NOT EXECUTED return return_status; 111df0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 111df5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111df7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111dfa: 5b pop %ebx <== NOT EXECUTED 111dfb: 5e pop %esi <== NOT EXECUTED 111dfc: c9 leave <== NOT EXECUTED 111dfd: c3 ret <== NOT EXECUTED 00111e00 : rtems_status_code rtems_region_ident( rtems_name name, Objects_Id *id ) { 111e00: 55 push %ebp <== NOT EXECUTED 111e01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 111e06: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e09: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 111e0e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e11: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111e16: e8 59 32 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111e1b: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 111e22: c9 leave <== NOT EXECUTED 111e23: c3 ret <== NOT EXECUTED 00111e24 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 111e24: 55 push %ebp <== NOT EXECUTED 111e25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e27: 57 push %edi <== NOT EXECUTED 111e28: 56 push %esi <== NOT EXECUTED 111e29: 53 push %ebx <== NOT EXECUTED 111e2a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111e2d: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 111e30: 85 ff test %edi,%edi <== NOT EXECUTED 111e32: 0f 84 aa 00 00 00 je 111ee2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111e38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e3b: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111e41: e8 fe 1a 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111e46: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111e49: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 111e4c: 50 push %eax <== NOT EXECUTED 111e4d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e50: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111e55: e8 96 30 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111e5a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111e5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e5f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111e62: 85 c0 test %eax,%eax <== NOT EXECUTED 111e64: 74 1f je 111e85 <== NOT EXECUTED 111e66: 31 db xor %ebx,%ebx <== NOT EXECUTED 111e68: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111e6b: 0f 95 c3 setne %bl <== NOT EXECUTED 111e6e: 4b dec %ebx <== NOT EXECUTED 111e6f: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111e72: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111e75: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e78: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111e7e: e8 09 1b 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111e83: eb 39 jmp 111ebe <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 111e85: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e88: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111e8b: 50 push %eax <== NOT EXECUTED 111e8c: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 111e8f: 50 push %eax <== NOT EXECUTED 111e90: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 111e93: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e96: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 111e99: 50 push %eax <== NOT EXECUTED 111e9a: e8 19 29 00 00 call 1147b8 <_Heap_Resize_block> <== NOT EXECUTED 111e9f: 89 c6 mov %eax,%esi <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 111ea1: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111ea4: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 111ea6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 111ea9: 85 f6 test %esi,%esi <== NOT EXECUTED 111eab: 75 16 jne 111ec3 <== NOT EXECUTED 111ead: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 111eb1: 74 10 je 111ec3 <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ 111eb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111eb6: 53 push %ebx <== NOT EXECUTED 111eb7: e8 c4 61 00 00 call 118080 <_Region_Process_queue> <== NOT EXECUTED 111ebc: 31 db xor %ebx,%ebx <== NOT EXECUTED 111ebe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ec1: eb 24 jmp 111ee7 <== NOT EXECUTED else _RTEMS_Unlock_allocator(); 111ec3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111ec6: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111ecc: e8 bb 1a 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED return 111ed1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ed4: 31 db xor %ebx,%ebx <== NOT EXECUTED 111ed6: 85 f6 test %esi,%esi <== NOT EXECUTED 111ed8: 74 0d je 111ee7 <== NOT EXECUTED 111eda: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 111edf: 4e dec %esi <== NOT EXECUTED 111ee0: 74 05 je 111ee7 <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 111ee2: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 111ee7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111ee9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111eec: 5b pop %ebx <== NOT EXECUTED 111eed: 5e pop %esi <== NOT EXECUTED 111eee: 5f pop %edi <== NOT EXECUTED 111eef: c9 leave <== NOT EXECUTED 111ef0: c3 ret <== NOT EXECUTED 00111ef4 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 111ef4: 55 push %ebp <== NOT EXECUTED 111ef5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111ef7: 56 push %esi <== NOT EXECUTED 111ef8: 53 push %ebx <== NOT EXECUTED 111ef9: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 111efc: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111f02: e8 3d 1a 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111f07: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111f0a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111f0d: 50 push %eax <== NOT EXECUTED 111f0e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f11: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111f16: e8 d5 2f 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111f1b: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111f1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f20: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 111f23: 85 c0 test %eax,%eax <== NOT EXECUTED 111f25: 74 11 je 111f38 <== NOT EXECUTED 111f27: 31 db xor %ebx,%ebx <== NOT EXECUTED 111f29: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111f2c: 0f 95 c3 setne %bl <== NOT EXECUTED 111f2f: 4b dec %ebx <== NOT EXECUTED 111f30: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111f33: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111f36: eb 2a jmp 111f62 <== NOT EXECUTED ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 111f38: 50 push %eax <== NOT EXECUTED 111f39: 50 push %eax <== NOT EXECUTED 111f3a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f3d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111f40: 50 push %eax <== NOT EXECUTED 111f41: e8 82 24 00 00 call 1143c8 <_Heap_Free> <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 111f46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else { the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator */ return RTEMS_SUCCESSFUL; 111f49: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 111f4e: 84 c0 test %al,%al <== NOT EXECUTED 111f50: 74 10 je 111f62 <== NOT EXECUTED return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 111f52: ff 4e 64 decl 0x64(%esi) <== NOT EXECUTED _Region_Process_queue(the_region); /* unlocks allocator */ 111f55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f58: 56 push %esi <== NOT EXECUTED 111f59: e8 22 61 00 00 call 118080 <_Region_Process_queue> <== NOT EXECUTED 111f5e: 30 db xor %bl,%bl <== NOT EXECUTED 111f60: eb 0e jmp 111f70 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111f62: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f65: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111f6b: e8 1c 1a 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111f70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111f73: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111f75: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111f78: 5b pop %ebx <== NOT EXECUTED 111f79: 5e pop %esi <== NOT EXECUTED 111f7a: c9 leave <== NOT EXECUTED 111f7b: c3 ret <== NOT EXECUTED 00108f14 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 108f14: 55 push %ebp <== NOT EXECUTED 108f15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f17: 57 push %edi <== NOT EXECUTED 108f18: 56 push %esi <== NOT EXECUTED 108f19: 53 push %ebx <== NOT EXECUTED 108f1a: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 108f1d: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 108f20: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 108f25: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 108f29: 0f 84 7f 01 00 00 je 1090ae <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 108f2f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108f34: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 108f38: 0f 84 70 01 00 00 je 1090ae <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 108f3e: 89 da mov %ebx,%edx <== NOT EXECUTED 108f40: 81 e2 c0 00 00 00 and $0xc0,%edx <== NOT EXECUTED 108f46: 74 28 je 108f70 <== NOT EXECUTED * @param[in] alignment the required alignment * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, 108f48: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108f4a: 83 e0 30 and $0x30,%eax <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 108f4d: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 108f50: 74 09 je 108f5b <== NOT EXECUTED 108f52: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 108f55: 0f 85 4e 01 00 00 jne 1090a9 <== NOT EXECUTED 108f5b: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 108f5e: 0f 84 45 01 00 00 je 1090a9 <== NOT EXECUTED _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 108f64: 81 fa c0 00 00 00 cmp $0xc0,%edx <== NOT EXECUTED 108f6a: 0f 84 39 01 00 00 je 1090a9 <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 108f70: 89 df mov %ebx,%edi <== NOT EXECUTED 108f72: 83 e7 30 and $0x30,%edi <== NOT EXECUTED 108f75: 74 0f je 108f86 <== NOT EXECUTED 108f77: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108f7c: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 108f80: 0f 87 28 01 00 00 ja 1090ae <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108f86: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108f8b: 40 inc %eax <== NOT EXECUTED 108f8c: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 108f91: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f94: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 108f99: e8 1e 12 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 108f9e: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 108fa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fa3: 85 c0 test %eax,%eax <== NOT EXECUTED 108fa5: 75 0f jne 108fb6 <== NOT EXECUTED _Thread_Enable_dispatch(); 108fa7: e8 14 1e 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 108fac: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 108fb1: e9 f8 00 00 00 jmp 1090ae <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 108fb6: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED * If it is not a counting semaphore, then it is either a * simple binary semaphore or a more powerful mutex style binary * semaphore. */ if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { 108fb9: 85 ff test %edi,%edi <== NOT EXECUTED 108fbb: 0f 84 92 00 00 00 je 109053 <== NOT EXECUTED CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 108fc1: f6 c3 40 test $0x40,%bl <== NOT EXECUTED 108fc4: 74 09 je 108fcf <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 108fc6: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) <== NOT EXECUTED 108fcd: eb 18 jmp 108fe7 <== NOT EXECUTED else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 108fcf: 84 db test %bl,%bl <== NOT EXECUTED 108fd1: 79 09 jns 108fdc <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 108fd3: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) <== NOT EXECUTED 108fda: eb 0b jmp 108fe7 <== NOT EXECUTED else if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 108fdc: 31 c0 xor %eax,%eax <== NOT EXECUTED 108fde: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 108fe1: 0f 95 c0 setne %al <== NOT EXECUTED 108fe4: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 108fe7: 83 ff 10 cmp $0x10,%edi <== NOT EXECUTED 108fea: 75 1a jne 109006 <== NOT EXECUTED the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 108fec: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED switch ( the_mutex_attributes.discipline ) { 108ff3: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108ff6: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108ff9: 76 12 jbe 10900d <== NOT EXECUTED 108ffb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 108ffe: 77 11 ja 109011 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 109000: c6 45 e0 01 movb $0x1,-0x20(%ebp) <== NOT EXECUTED 109004: eb 0b jmp 109011 <== NOT EXECUTED break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 109006: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.only_owner_release = FALSE; 10900d: c6 45 e0 00 movb $0x0,-0x20(%ebp) <== NOT EXECUTED } the_mutex_attributes.priority_ceiling = priority_ceiling; 109011: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 109014: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED mutex_status = _CORE_mutex_Initialize( 109017: 51 push %ecx <== NOT EXECUTED 109018: 31 c0 xor %eax,%eax <== NOT EXECUTED 10901a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10901e: 0f 94 c0 sete %al <== NOT EXECUTED 109021: 50 push %eax <== NOT EXECUTED 109022: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 109025: 50 push %eax <== NOT EXECUTED 109026: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 109029: 50 push %eax <== NOT EXECUTED 10902a: e8 4d 0b 00 00 call 109b7c <_CORE_mutex_Initialize> <== NOT EXECUTED &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10902f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109032: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 109035: 75 50 jne 109087 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 109037: 52 push %edx <== NOT EXECUTED 109038: 52 push %edx <== NOT EXECUTED 109039: 56 push %esi <== NOT EXECUTED 10903a: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 10903f: e8 88 14 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 109044: e8 77 1d 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109049: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10904e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109051: eb 5b jmp 1090ae <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 109053: 31 c0 xor %eax,%eax <== NOT EXECUTED 109055: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 109058: 0f 95 c0 setne %al <== NOT EXECUTED 10905b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10905e: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 109065: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 10906c: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED _CORE_semaphore_Initialize( 109073: 50 push %eax <== NOT EXECUTED 109074: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109077: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10907a: 50 push %eax <== NOT EXECUTED 10907b: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10907e: 50 push %eax <== NOT EXECUTED 10907f: e8 74 0d 00 00 call 109df8 <_CORE_semaphore_Initialize> <== NOT EXECUTED 109084: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109087: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10908a: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10908d: a1 64 c9 11 00 mov 0x11c964,%eax <== NOT EXECUTED 109092: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 109095: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109098: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10909b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10909e: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1090a0: e8 1b 1d 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1090a5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1090a7: eb 05 jmp 1090ae <== NOT EXECUTED return RTEMS_SUCCESSFUL; 1090a9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED } 1090ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1090b1: 5b pop %ebx <== NOT EXECUTED 1090b2: 5e pop %esi <== NOT EXECUTED 1090b3: 5f pop %edi <== NOT EXECUTED 1090b4: c9 leave <== NOT EXECUTED 1090b5: c3 ret <== NOT EXECUTED 001090b8 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 1090b8: 55 push %ebp <== NOT EXECUTED 1090b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090bb: 53 push %ebx <== NOT EXECUTED 1090bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1090bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1090c2: 50 push %eax <== NOT EXECUTED 1090c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1090c6: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 1090cb: e8 30 15 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 1090d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 1090d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090d5: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1090da: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1090de: 75 61 jne 109141 <== NOT EXECUTED ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 1090e0: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 1090e3: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 1090e6: 74 27 je 10910f <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 1090e8: 83 7b 64 00 cmpl $0x0,0x64(%ebx) <== NOT EXECUTED 1090ec: 75 11 jne 1090ff <== NOT EXECUTED 1090ee: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 1090f1: 74 0c je 1090ff <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 1090f3: e8 c8 1c 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1090f8: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 1090fd: eb 42 jmp 109141 <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 1090ff: 50 push %eax <== NOT EXECUTED 109100: 6a 04 push $0x4 <== NOT EXECUTED 109102: 6a 00 push $0x0 <== NOT EXECUTED 109104: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109107: 50 push %eax <== NOT EXECUTED 109108: e8 63 0a 00 00 call 109b70 <_CORE_mutex_Flush> <== NOT EXECUTED 10910d: eb 0e jmp 10911d <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10910f: 50 push %eax <== NOT EXECUTED 109110: 6a 02 push $0x2 <== NOT EXECUTED 109112: 6a 00 push $0x0 <== NOT EXECUTED 109114: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109117: 50 push %eax <== NOT EXECUTED 109118: e8 cf 0c 00 00 call 109dec <_CORE_semaphore_Flush> <== NOT EXECUTED 10911d: 59 pop %ecx <== NOT EXECUTED 10911e: 58 pop %eax <== NOT EXECUTED SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10911f: 53 push %ebx <== NOT EXECUTED 109120: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109125: e8 06 11 00 00 call 10a230 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10912a: 58 pop %eax <== NOT EXECUTED 10912b: 5a pop %edx <== NOT EXECUTED 10912c: 53 push %ebx <== NOT EXECUTED 10912d: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109132: e8 95 13 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 109137: e8 84 1c 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10913c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10913e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109141: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109144: c9 leave <== NOT EXECUTED 109145: c3 ret <== NOT EXECUTED 0012108c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 12108c: 55 push %ebp <== NOT EXECUTED 12108d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12108f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 121092: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 121095: 50 push %eax <== NOT EXECUTED 121096: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121099: 68 3c 9b 15 00 push $0x159b3c <== NOT EXECUTED 12109e: e8 2d e0 fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 1210a3: 89 c2 mov %eax,%edx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 1210a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1210a8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1210ad: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 1210b1: 75 2b jne 1210de <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 1210b3: f6 42 10 30 testb $0x30,0x10(%edx) <== NOT EXECUTED 1210b7: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 1210ba: 74 0d je 1210c9 <== NOT EXECUTED _CORE_mutex_Flush( 1210bc: 51 push %ecx <== NOT EXECUTED 1210bd: 6a 01 push $0x1 <== NOT EXECUTED 1210bf: 6a 00 push $0x0 <== NOT EXECUTED 1210c1: 50 push %eax <== NOT EXECUTED 1210c2: e8 49 d4 fe ff call 10e510 <_CORE_mutex_Flush> <== NOT EXECUTED 1210c7: eb 0b jmp 1210d4 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 1210c9: 52 push %edx <== NOT EXECUTED 1210ca: 6a 01 push $0x1 <== NOT EXECUTED 1210cc: 6a 00 push $0x0 <== NOT EXECUTED 1210ce: 50 push %eax <== NOT EXECUTED 1210cf: e8 b8 d6 fe ff call 10e78c <_CORE_semaphore_Flush> <== NOT EXECUTED 1210d4: 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(); 1210d7: e8 64 e8 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1210dc: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1210de: c9 leave <== NOT EXECUTED 1210df: c3 ret <== NOT EXECUTED 00112204 : rtems_status_code rtems_semaphore_ident( rtems_name name, uint32_t node, rtems_id *id ) { 112204: 55 push %ebp <== NOT EXECUTED 112205: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112207: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Semaphore_Information, name, node, id ); 11220a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11220d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112210: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112213: 68 d4 26 13 00 push $0x1326d4 <== NOT EXECUTED 112218: e8 57 2e 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11221d: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 112224: c9 leave <== NOT EXECUTED 112225: c3 ret <== NOT EXECUTED 00109148 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 109148: 55 push %ebp <== NOT EXECUTED 109149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10914b: 57 push %edi <== NOT EXECUTED 10914c: 56 push %esi <== NOT EXECUTED 10914d: 53 push %ebx <== NOT EXECUTED 10914e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109151: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109154: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size 109157: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10915a: 50 push %eax <== NOT EXECUTED 10915b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10915e: 50 push %eax <== NOT EXECUTED 10915f: 57 push %edi <== NOT EXECUTED 109160: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109165: e8 4a 14 00 00 call 10a5b4 <_Objects_Get_isr_disable> <== NOT EXECUTED 10916a: 89 c1 mov %eax,%ecx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 10916c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10916f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109174: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109178: 0f 85 a8 00 00 00 jne 109226 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10917e: f6 41 10 30 testb $0x30,0x10(%ecx) <== NOT EXECUTED 109182: 74 2c je 1091b0 <== NOT EXECUTED _CORE_mutex_Seize( 109184: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109187: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10918a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10918d: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 109190: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 109193: 53 push %ebx <== NOT EXECUTED 109194: 57 push %edi <== NOT EXECUTED 109195: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 109198: 50 push %eax <== NOT EXECUTED 109199: e8 ca 0a 00 00 call 109c68 <_CORE_mutex_Seize> <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10919e: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 1091a1: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 1091a6: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1091a9: e8 f2 00 00 00 call 1092a0 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 1091ae: eb 73 jmp 109223 <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon 1091b0: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( 1091b3: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED Heap_Control *the_heap, 1091b9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED size_t size 1091c0: 8b 41 5c mov 0x5c(%ecx),%eax <== NOT EXECUTED 1091c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1091c5: 74 08 je 1091cf <== NOT EXECUTED ); 1091c7: 48 dec %eax <== NOT EXECUTED 1091c8: 89 41 5c mov %eax,0x5c(%ecx) <== NOT EXECUTED 1091cb: 56 push %esi <== NOT EXECUTED 1091cc: 9d popf <== NOT EXECUTED 1091cd: eb 44 jmp 109213 <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 1091cf: 80 e3 01 and $0x1,%bl <== NOT EXECUTED 1091d2: 74 0b je 1091df <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd 1091d4: 56 push %esi <== NOT EXECUTED 1091d5: 9d popf <== NOT EXECUTED * alignments are possible. 1091d6: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) <== NOT EXECUTED 1091dd: eb 34 jmp 109213 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1091df: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 1091e4: 40 inc %eax <== NOT EXECUTED 1091e5: a3 00 ca 11 00 mov %eax,0x11ca00 <== 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 1091ea: c7 41 44 01 00 00 00 movl $0x1,0x44(%ecx) <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 1091f1: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 1091f4: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 1091f7: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED */ 1091fa: 56 push %esi <== NOT EXECUTED 1091fb: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 1091fc: 52 push %edx <== NOT EXECUTED 1091fd: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109202: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109205: 50 push %eax <== NOT EXECUTED 109206: e8 05 20 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10920b: e8 b0 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109210: 83 c4 10 add $0x10,%esp <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 109213: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109216: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10921b: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10921e: e8 8c 00 00 00 call 1092af <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 109223: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 109226: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109229: 5b pop %ebx <== NOT EXECUTED 10922a: 5e pop %esi <== NOT EXECUTED 10922b: 5f pop %edi <== NOT EXECUTED 10922c: c9 leave <== NOT EXECUTED 10922d: c3 ret <== NOT EXECUTED 00109230 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 109230: 55 push %ebp <== NOT EXECUTED 109231: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109233: 53 push %ebx <== NOT EXECUTED 109234: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 109237: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10923a: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10923d: 50 push %eax <== NOT EXECUTED 10923e: 53 push %ebx <== NOT EXECUTED 10923f: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109244: e8 b7 13 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 109249: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10924b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10924e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109253: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109257: 75 40 jne 109299 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 109259: f6 42 10 30 testb $0x30,0x10(%edx) <== NOT EXECUTED 10925d: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 109260: 74 1b je 10927d <== NOT EXECUTED mutex_status = _CORE_mutex_Surrender( 109262: 51 push %ecx <== NOT EXECUTED 109263: 6a 00 push $0x0 <== NOT EXECUTED 109265: 53 push %ebx <== NOT EXECUTED 109266: 50 push %eax <== NOT EXECUTED 109267: e8 8c 0a 00 00 call 109cf8 <_CORE_mutex_Surrender> <== NOT EXECUTED 10926c: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10926e: e8 4d 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 109273: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109276: e8 25 00 00 00 call 1092a0 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10927b: eb 19 jmp 109296 <== NOT EXECUTED } else { semaphore_status = _CORE_semaphore_Surrender( 10927d: 52 push %edx <== NOT EXECUTED 10927e: 6a 00 push $0x0 <== NOT EXECUTED 109280: 53 push %ebx <== NOT EXECUTED 109281: 50 push %eax <== NOT EXECUTED 109282: e8 b1 0b 00 00 call 109e38 <_CORE_semaphore_Surrender> <== NOT EXECUTED 109287: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 109289: e8 32 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return 10928e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109291: e8 19 00 00 00 call 1092af <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 109296: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109299: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10929c: c9 leave <== NOT EXECUTED 10929d: c3 ret <== NOT EXECUTED 00114dbc : */ void rtems_shutdown_executive( uint32_t result ) { 114dbc: 55 push %ebp <== NOT EXECUTED 114dbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114dbf: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 114dc2: 83 3d a0 cb 11 00 04 cmpl $0x4,0x11cba0 <== NOT EXECUTED 114dc9: 74 1d je 114de8 <== 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( 114dcb: c7 05 a0 cb 11 00 04 movl $0x4,0x11cba0 <== NOT EXECUTED 114dd2: 00 00 00 <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 114dd5: 50 push %eax <== NOT EXECUTED 114dd6: 50 push %eax <== NOT EXECUTED 114dd7: 68 e8 c9 11 00 push $0x11c9e8 <== NOT EXECUTED 114ddc: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 114ddf: 50 push %eax <== NOT EXECUTED 114de0: e8 0b 70 ff ff call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED 114de5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 114de8: c9 leave <== NOT EXECUTED 114de9: c3 ret <== NOT EXECUTED 00109ec4 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 109ec4: 55 push %ebp <== NOT EXECUTED 109ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ec7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109eca: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; /* XXX normalize mode */ executing = _Thread_Executing; api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ]; 109ecd: a1 ac f5 11 00 mov 0x11f5ac,%eax <== NOT EXECUTED 109ed2: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109ed8: a1 ec f4 11 00 mov 0x11f4ec,%eax <== NOT EXECUTED 109edd: 40 inc %eax <== NOT EXECUTED 109ede: a3 ec f4 11 00 mov %eax,0x11f4ec <== NOT EXECUTED asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 109ee3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109ee5: 74 0b je 109ef2 <== NOT EXECUTED asr->mode_set = mode_set; 109ee7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109eea: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED asr->handler = asr_handler; 109eed: 89 4a 0c mov %ecx,0xc(%edx) <== NOT EXECUTED 109ef0: eb 27 jmp 109f19 <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 109ef2: 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 109ef6: 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. 109efd: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 109f04: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109f0b: 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 109f12: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 109f19: e8 ee 1d 00 00 call 10bd0c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109f1e: 31 c0 xor %eax,%eax <== NOT EXECUTED 109f20: c9 leave <== NOT EXECUTED 109f21: c3 ret <== NOT EXECUTED 001123a0 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 1123a0: 55 push %ebp <== NOT EXECUTED 1123a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1123a3: 53 push %ebx <== NOT EXECUTED 1123a4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1123a7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 1123aa: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1123af: 85 db test %ebx,%ebx <== NOT EXECUTED 1123b1: 74 71 je 112424 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 1123b3: 50 push %eax <== NOT EXECUTED 1123b4: 50 push %eax <== NOT EXECUTED 1123b5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1123b8: 50 push %eax <== NOT EXECUTED 1123b9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1123bc: e8 4b 33 00 00 call 11570c <_Thread_Get> <== NOT EXECUTED 1123c1: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 1123c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1123c6: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1123cb: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1123cf: 75 53 jne 112424 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 1123d1: 8b 91 f4 00 00 00 mov 0xf4(%ecx),%edx <== NOT EXECUTED asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 1123d7: 83 7a 0c 00 cmpl $0x0,0xc(%edx) <== NOT EXECUTED 1123db: 74 3d je 11241a <== NOT EXECUTED if ( asr->is_enabled ) { 1123dd: 80 7a 08 00 cmpb $0x0,0x8(%edx) <== NOT EXECUTED 1123e1: 74 26 je 112409 <== 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 1123e3: 9c pushf <== NOT EXECUTED 1123e4: fa cli <== NOT EXECUTED 1123e5: 58 pop %eax <== NOT EXECUTED ); 1123e6: 09 5a 14 or %ebx,0x14(%edx) <== NOT EXECUTED 1123e9: 50 push %eax <== NOT EXECUTED 1123ea: 9d popf <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 1123eb: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1123ef: a1 7c 28 13 00 mov 0x13287c,%eax <== NOT EXECUTED 1123f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1123f6: 74 19 je 112411 <== NOT EXECUTED 1123f8: 3b 0d a0 28 13 00 cmp 0x1328a0,%ecx <== NOT EXECUTED 1123fe: 75 11 jne 112411 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 112400: c6 05 34 29 13 00 01 movb $0x1,0x132934 <== NOT EXECUTED 112407: eb 08 jmp 112411 <== 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 112409: 9c pushf <== NOT EXECUTED 11240a: fa cli <== NOT EXECUTED 11240b: 58 pop %eax <== NOT EXECUTED ); 11240c: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 11240f: 50 push %eax <== NOT EXECUTED 112410: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 112411: e8 d6 32 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112416: 31 c0 xor %eax,%eax <== NOT EXECUTED 112418: eb 0a jmp 112424 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11241a: e8 cd 32 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11241f: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112424: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112427: c9 leave <== NOT EXECUTED 112428: c3 ret <== NOT EXECUTED 0010856c : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 10856c: 55 push %ebp <== NOT EXECUTED 10856d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10856f: 57 push %edi <== NOT EXECUTED 108570: 56 push %esi <== NOT EXECUTED 108571: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 108574: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED 108578: 74 15 je 10858f <== NOT EXECUTED return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 10857a: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax <== NOT EXECUTED 108580: 8d 78 08 lea 0x8(%eax),%edi <== NOT EXECUTED 108583: be 70 9a 15 00 mov $0x159a70,%esi <== NOT EXECUTED 108588: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10858d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } 10858f: 5e pop %esi <== NOT EXECUTED 108590: 5f pop %edi <== NOT EXECUTED 108591: c9 leave <== NOT EXECUTED 108592: c3 ret <== NOT EXECUTED 001088f4 : */ bool rtems_stack_checker_create_extension( Thread_Control *running, Thread_Control *the_thread ) { 1088f4: 55 push %ebp <== NOT EXECUTED 1088f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1088f7: 57 push %edi <== NOT EXECUTED 1088f8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1088fb: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Stack_check_Initialize(); 1088fe: e8 84 ff ff ff call 108887 <== NOT EXECUTED if (the_thread) 108903: 85 ff test %edi,%edi <== NOT EXECUTED 108905: 74 10 je 108917 <== NOT EXECUTED Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 108907: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx <== NOT EXECUTED 10890d: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi <== NOT EXECUTED 108913: b0 a5 mov $0xa5,%al <== NOT EXECUTED 108915: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED return true; } 108917: b0 01 mov $0x1,%al <== NOT EXECUTED 108919: 5a pop %edx <== NOT EXECUTED 10891a: 5f pop %edi <== NOT EXECUTED 10891b: c9 leave <== NOT EXECUTED 10891c: c3 ret <== NOT EXECUTED 001087b5 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 1087b5: 55 push %ebp <== NOT EXECUTED 1087b6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1087b8: 53 push %ebx <== NOT EXECUTED 1087b9: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 1087bc: a1 b4 9c 15 00 mov 0x159cb4,%eax <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1087c1: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED 1087c7: 31 db xor %ebx,%ebx <== NOT EXECUTED 1087c9: 39 d5 cmp %edx,%ebp <== NOT EXECUTED 1087cb: 72 0e jb 1087db <== NOT EXECUTED 1087cd: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED 1087d3: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 1087d6: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 1087d8: 0f 96 c3 setbe %bl <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 1087db: b0 01 mov $0x1,%al <== NOT EXECUTED 1087dd: 83 3d 78 69 14 00 00 cmpl $0x0,0x146978 <== NOT EXECUTED 1087e4: 74 19 je 1087ff <== NOT EXECUTED pattern_ok = (!memcmp( 1087e6: 51 push %ecx <== NOT EXECUTED 1087e7: 6a 10 push $0x10 <== NOT EXECUTED 1087e9: 68 70 9a 15 00 push $0x159a70 <== NOT EXECUTED 1087ee: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED 1087f1: 50 push %eax <== NOT EXECUTED 1087f2: e8 01 44 02 00 call 12cbf8 <== NOT EXECUTED 1087f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1087fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1087fc: 0f 94 c0 sete %al <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 1087ff: 84 db test %bl,%bl <== NOT EXECUTED 108801: 74 06 je 108809 <== NOT EXECUTED 108803: 31 d2 xor %edx,%edx <== NOT EXECUTED 108805: 84 c0 test %al,%al <== NOT EXECUTED 108807: 75 16 jne 10881f <== NOT EXECUTED return false; /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 108809: 52 push %edx <== NOT EXECUTED 10880a: 52 push %edx <== NOT EXECUTED 10880b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10880e: 50 push %eax <== NOT EXECUTED 10880f: ff 35 b4 9c 15 00 pushl 0x159cb4 <== NOT EXECUTED 108815: e8 34 ff ff ff call 10874e <== NOT EXECUTED 10881a: b2 01 mov $0x1,%dl <== NOT EXECUTED 10881c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 10881f: 88 d0 mov %dl,%al <== NOT EXECUTED 108821: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108824: c9 leave <== NOT EXECUTED 108825: c3 ret <== NOT EXECUTED 00108737 : void rtems_stack_checker_report_usage( void ) { 108737: 55 push %ebp <== NOT EXECUTED 108738: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10873a: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 10873d: 68 e4 b1 10 00 push $0x10b1e4 <== NOT EXECUTED 108742: 6a 00 push $0x0 <== NOT EXECUTED 108744: e8 8d ff ff ff call 1086d6 <== NOT EXECUTED 108749: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10874c: c9 leave <== NOT EXECUTED 10874d: c3 ret <== NOT EXECUTED 001086d6 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 1086d6: 55 push %ebp <== NOT EXECUTED 1086d7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1086d9: 56 push %esi <== NOT EXECUTED 1086da: 53 push %ebx <== NOT EXECUTED 1086db: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1086de: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED print_context = context; 1086e1: 89 1d 7c 69 14 00 mov %ebx,0x14697c <== NOT EXECUTED print_handler = print; 1086e7: 89 35 80 69 14 00 mov %esi,0x146980 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1086ed: 51 push %ecx <== NOT EXECUTED 1086ee: 51 push %ecx <== NOT EXECUTED 1086ef: 68 dd a8 13 00 push $0x13a8dd <== NOT EXECUTED 1086f4: 53 push %ebx <== NOT EXECUTED 1086f5: ff d6 call *%esi <== NOT EXECUTED (*print)( context, 1086f7: 58 pop %eax <== NOT EXECUTED 1086f8: 5a pop %edx <== NOT EXECUTED 1086f9: 68 f4 a8 13 00 push $0x13a8f4 <== NOT EXECUTED 1086fe: 53 push %ebx <== NOT EXECUTED 1086ff: 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 ); 108701: c7 04 24 be 85 10 00 movl $0x1085be,(%esp) <== NOT EXECUTED 108708: e8 4f 64 00 00 call 10eb5c <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 10870d: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 108714: e8 a5 fe ff ff call 1085be <== NOT EXECUTED print_context = NULL; 108719: c7 05 7c 69 14 00 00 movl $0x0,0x14697c <== NOT EXECUTED 108720: 00 00 00 <== NOT EXECUTED print_handler = NULL; 108723: c7 05 80 69 14 00 00 movl $0x0,0x146980 <== NOT EXECUTED 10872a: 00 00 00 <== NOT EXECUTED 10872d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108730: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108733: 5b pop %ebx <== NOT EXECUTED 108734: 5e pop %esi <== NOT EXECUTED 108735: c9 leave <== NOT EXECUTED 108736: c3 ret <== NOT EXECUTED 00108826 : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 108826: 55 push %ebp <== NOT EXECUTED 108827: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108829: 56 push %esi <== NOT EXECUTED 10882a: 53 push %ebx <== NOT EXECUTED 10882b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; bool sp_ok; bool pattern_ok = true; pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern; 10882e: 8b 93 c8 00 00 00 mov 0xc8(%ebx),%edx <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 108834: 31 f6 xor %esi,%esi <== NOT EXECUTED 108836: 39 d5 cmp %edx,%ebp <== NOT EXECUTED 108838: 72 0f jb 108849 <== NOT EXECUTED 10883a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10883c: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax <== NOT EXECUTED 108842: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 108844: 0f 96 c0 setbe %al <== NOT EXECUTED 108847: 89 c6 mov %eax,%esi <== 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, 108849: 50 push %eax <== NOT EXECUTED 10884a: 6a 10 push $0x10 <== NOT EXECUTED 10884c: 68 70 9a 15 00 push $0x159a70 <== NOT EXECUTED 108851: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED 108854: 50 push %eax <== NOT EXECUTED 108855: e8 9e 43 02 00 call 12cbf8 <== NOT EXECUTED 10885a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10885d: 85 c0 test %eax,%eax <== NOT EXECUTED 10885f: 0f 94 c0 sete %al <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 108862: 89 f2 mov %esi,%edx <== NOT EXECUTED 108864: 84 d2 test %dl,%dl <== NOT EXECUTED 108866: 74 04 je 10886c <== NOT EXECUTED 108868: 84 c0 test %al,%al <== NOT EXECUTED 10886a: 75 14 jne 108880 <== NOT EXECUTED Stack_check_report_blown_task( running, pattern_ok ); 10886c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10886f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 108872: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 108875: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108878: 5b pop %ebx <== NOT EXECUTED 108879: 5e pop %esi <== NOT EXECUTED 10887a: 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 ); 10887b: e9 ce fe ff ff jmp 10874e <== NOT EXECUTED } } 108880: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108883: 5b pop %ebx <== NOT EXECUTED 108884: 5e pop %esi <== NOT EXECUTED 108885: c9 leave <== NOT EXECUTED 108886: c3 ret <== NOT EXECUTED 00109414 : const char * rtems_status_text( rtems_status_code status ) { 109414: 55 push %ebp <== NOT EXECUTED 109415: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109417: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 10941a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10941d: 68 8c fa 11 00 push $0x11fa8c <== NOT EXECUTED 109422: e8 ad 85 00 00 call 1119d4 <== NOT EXECUTED } 109427: c9 leave <== NOT EXECUTED 109428: c3 ret <== NOT EXECUTED 001092c0 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 1092c0: 55 push %ebp <== NOT EXECUTED 1092c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092c3: 57 push %edi <== NOT EXECUTED 1092c4: 56 push %esi <== NOT EXECUTED 1092c5: 53 push %ebx <== NOT EXECUTED 1092c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1092c9: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 1092cc: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 1092cf: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1092d4: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 1092d8: 0f 84 08 01 00 00 je 1093e6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 1092de: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 1092e3: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 1092e7: 0f 84 f9 00 00 00 je 1093e6 <== NOT EXECUTED /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 1092ed: 66 85 ff test %di,%di <== NOT EXECUTED 1092f0: 78 24 js 109316 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 1092f2: 31 d2 xor %edx,%edx <== NOT EXECUTED 1092f4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 1092f8: 74 0f je 109309 <== NOT EXECUTED 1092fa: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 109301: 31 d2 xor %edx,%edx <== NOT EXECUTED 109303: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 109306: 0f 96 c2 setbe %dl <== NOT EXECUTED if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) ) 109309: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10930e: 85 d2 test %edx,%edx <== NOT EXECUTED 109310: 0f 84 d0 00 00 00 je 1093e6 <== NOT EXECUTED */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109316: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109319: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10931f: e8 88 06 00 00 call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109324: c7 04 24 88 c9 11 00 movl $0x11c988,(%esp) <== NOT EXECUTED 10932b: e8 8c 0e 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 109330: 89 c6 mov %eax,%esi <== NOT EXECUTED * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 109332: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109335: 85 c0 test %eax,%eax <== NOT EXECUTED 109337: 75 18 jne 109351 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 109339: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10933c: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 109342: e8 ad 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 109347: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10934c: e9 92 00 00 00 jmp 1093e3 <== NOT EXECUTED /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 109351: 50 push %eax <== NOT EXECUTED 109352: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109355: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109357: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10935a: 50 push %eax <== NOT EXECUTED 10935b: 6a 00 push $0x0 <== NOT EXECUTED 10935d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10935f: c1 e8 09 shr $0x9,%eax <== NOT EXECUTED 109362: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 109365: 50 push %eax <== NOT EXECUTED 109366: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109368: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10936b: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10936e: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 109371: 50 push %eax <== NOT EXECUTED 109372: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109375: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 109378: 57 push %edi <== NOT EXECUTED 109379: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10937c: 6a 00 push $0x0 <== NOT EXECUTED 10937e: 56 push %esi <== NOT EXECUTED 10937f: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 109384: e8 cf 1a 00 00 call 10ae58 <_Thread_Initialize> <== NOT EXECUTED NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 109389: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10938c: 84 c0 test %al,%al <== NOT EXECUTED 10938e: 75 27 jne 1093b7 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 109390: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109393: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 109396: e8 a5 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 10939b: 5a pop %edx <== NOT EXECUTED 10939c: 59 pop %ecx <== NOT EXECUTED 10939d: 56 push %esi <== NOT EXECUTED 10939e: 50 push %eax <== NOT EXECUTED 10939f: e8 28 11 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 1093a4: 58 pop %eax <== NOT EXECUTED 1093a5: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093ab: e8 44 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 1093b0: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 1093b5: eb 2c jmp 1093e3 <== NOT EXECUTED } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 1093b7: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax <== NOT EXECUTED 1093bd: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 1093c0: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 1093c3: 88 da mov %bl,%dl <== NOT EXECUTED 1093c5: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 1093c8: 88 50 08 mov %dl,0x8(%eax) <== NOT EXECUTED *id = the_thread->Object.id; 1093cb: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 1093ce: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 1093d1: 89 02 mov %eax,(%edx) <== NOT EXECUTED ); } #endif _RTEMS_Unlock_allocator(); 1093d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1093d6: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093dc: e8 13 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 1093e1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1093e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1093e6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1093e9: 5b pop %ebx <== NOT EXECUTED 1093ea: 5e pop %esi <== NOT EXECUTED 1093eb: 5f pop %edi <== NOT EXECUTED 1093ec: c9 leave <== NOT EXECUTED 1093ed: c3 ret <== NOT EXECUTED 001093f0 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 1093f0: 55 push %ebp <== NOT EXECUTED 1093f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1093f3: 53 push %ebx <== NOT EXECUTED 1093f4: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 1093f7: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093fd: e8 aa 05 00 00 call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); 109402: 5b pop %ebx <== NOT EXECUTED 109403: 58 pop %eax <== NOT EXECUTED 109404: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109407: 50 push %eax <== NOT EXECUTED 109408: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10940b: e8 d0 19 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 109410: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 109412: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109415: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109419: 75 3b jne 109456 <== NOT EXECUTED case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10941b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10941e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109421: e8 1a 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 109426: 5a pop %edx <== NOT EXECUTED 109427: 59 pop %ecx <== NOT EXECUTED 109428: 53 push %ebx <== NOT EXECUTED 109429: 50 push %eax <== NOT EXECUTED 10942a: e8 99 16 00 00 call 10aac8 <_Thread_Close> <== NOT EXECUTED 10942f: 58 pop %eax <== NOT EXECUTED 109430: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 109433: e8 08 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 109438: 5a pop %edx <== NOT EXECUTED 109439: 59 pop %ecx <== NOT EXECUTED 10943a: 53 push %ebx <== NOT EXECUTED 10943b: 50 push %eax <== NOT EXECUTED 10943c: e8 8b 10 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 109441: 58 pop %eax <== NOT EXECUTED 109442: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 109448: e8 a7 05 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10944d: e8 6e 19 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109452: 31 c0 xor %eax,%eax <== NOT EXECUTED 109454: eb 13 jmp 109469 <== NOT EXECUTED case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 109456: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109459: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10945f: e8 90 05 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 109464: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109469: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_INVALID_ID; } 10946c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10946f: c9 leave <== NOT EXECUTED 109470: c3 ret <== NOT EXECUTED 0010aa08 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10aa08: 55 push %ebp <== NOT EXECUTED 10aa09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa0b: 56 push %esi <== NOT EXECUTED 10aa0c: 53 push %ebx <== NOT EXECUTED 10aa0d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10aa10: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aa13: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10aa16: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10aa19: a1 ac 07 12 00 mov 0x1207ac,%eax <== NOT EXECUTED 10aa1e: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10aa21: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10aa26: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10aa2a: 74 61 je 10aa8d <== NOT EXECUTED return RTEMS_NOT_CONFIGURED; if ( !note ) 10aa2c: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10aa31: 85 f6 test %esi,%esi <== NOT EXECUTED 10aa33: 74 58 je 10aa8d <== 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 ) 10aa35: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10aa3a: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10aa3d: 77 4e ja 10aa8d <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10aa3f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa41: 74 0a je 10aa4d <== NOT EXECUTED 10aa43: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aa48: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10aa4b: 75 13 jne 10aa60 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa4d: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aa52: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa58: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa5c: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10aa5e: eb 2b jmp 10aa8b <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10aa60: 50 push %eax <== NOT EXECUTED 10aa61: 50 push %eax <== NOT EXECUTED 10aa62: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10aa65: 50 push %eax <== NOT EXECUTED 10aa66: 51 push %ecx <== NOT EXECUTED 10aa67: e8 38 1c 00 00 call 10c6a4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10aa6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa6f: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10aa74: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10aa78: 75 13 jne 10aa8d <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa7a: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa80: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa84: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aa86: e8 f9 1b 00 00 call 10c684 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aa8b: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10aa8d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10aa8f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aa92: 5b pop %ebx <== NOT EXECUTED 10aa93: 5e pop %esi <== NOT EXECUTED 10aa94: c9 leave <== NOT EXECUTED 10aa95: c3 ret <== NOT EXECUTED 00109474 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 109474: 55 push %ebp <== NOT EXECUTED 109475: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109477: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10947a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10947d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !id ) 109480: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109485: 85 d2 test %edx,%edx <== NOT EXECUTED 109487: 74 2b je 1094b4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 109489: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10948b: 75 0e jne 10949b <== NOT EXECUTED *id = _Thread_Executing->Object.id; 10948d: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 109492: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109495: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109497: 31 c0 xor %eax,%eax <== NOT EXECUTED 109499: eb 19 jmp 1094b4 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 10949b: 52 push %edx <== NOT EXECUTED 10949c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10949f: 51 push %ecx <== NOT EXECUTED 1094a0: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 1094a5: e8 9e 12 00 00 call 10a748 <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 1094aa: 8b 04 85 34 68 11 00 mov 0x116834(,%eax,4),%eax <== NOT EXECUTED 1094b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1094b4: c9 leave <== NOT EXECUTED 1094b5: c3 ret <== NOT EXECUTED 001099c0 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 1099c0: 55 push %ebp <== NOT EXECUTED 1099c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099c3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 1099c6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 1099c9: 50 push %eax <== NOT EXECUTED 1099ca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099cd: e8 a6 19 00 00 call 10b378 <_Thread_Get> <== NOT EXECUTED 1099d2: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 1099d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099d7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1099dc: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 1099e0: 75 19 jne 1099fb <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 1099e2: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 1099e6: 75 09 jne 1099f1 <== NOT EXECUTED _Thread_Enable_dispatch(); 1099e8: e8 6b 19 00 00 call 10b358 <_Thread_Enable_dispatch> <== NOT EXECUTED 1099ed: 31 c0 xor %eax,%eax <== NOT EXECUTED 1099ef: eb 0a jmp 1099fb <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1099f1: e8 62 19 00 00 call 10b358 <_Thread_Enable_dispatch> <== NOT EXECUTED 1099f6: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1099fb: c9 leave <== NOT EXECUTED 1099fc: c3 ret <== NOT EXECUTED 0010e280 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10e280: 55 push %ebp <== NOT EXECUTED 10e281: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e283: 57 push %edi <== NOT EXECUTED 10e284: 56 push %esi <== NOT EXECUTED 10e285: 53 push %ebx <== NOT EXECUTED 10e286: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e289: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10e28c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10e291: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10e295: 0f 84 04 01 00 00 je 10e39f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10e29b: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10e2a0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10e2a3: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 10e2a9: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10e2ac: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 10e2b0: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10e2b2: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10e2b8: 83 78 7c 00 cmpl $0x0,0x7c(%eax) <== NOT EXECUTED 10e2bc: 74 06 je 10e2c4 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10e2be: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10e2c4: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10e2c7: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 10e2cb: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10e2cd: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 10e2d3: e8 f3 dc ff ff call 10bfcb <_CPU_ISR_Get_level> <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10e2d8: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10e2da: 09 f3 or %esi,%ebx <== NOT EXECUTED 10e2dc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e2df: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10e2e1: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 10e2e8: 74 11 je 10e2fb <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10e2ea: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e2ec: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10e2ef: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10e2f2: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10e2f5: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10e2f8: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 10e2fb: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 10e302: 74 26 je 10e32a <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 10e304: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 10e30a: 74 14 je 10e320 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10e30c: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10e30f: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10e316: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10e31b: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10e31e: eb 0a jmp 10e32a <== NOT EXECUTED } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10e320: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e323: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10e32a: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10e32e: 74 0c je 10e33c <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10e330: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10e336: 74 03 je 10e33b <== NOT EXECUTED 10e338: fa cli <== NOT EXECUTED 10e339: eb 01 jmp 10e33c <== NOT EXECUTED 10e33b: fb sti <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10e33c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 10e343: 74 3b je 10e380 <== NOT EXECUTED 10e345: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 10e348: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 10e34b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e34d: 83 e0 01 and $0x1,%eax <== NOT EXECUTED is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 10e350: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e353: 3a 42 08 cmp 0x8(%edx),%al <== NOT EXECUTED 10e356: 74 28 je 10e380 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 10e358: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10e35b: 9c pushf <== NOT EXECUTED 10e35c: fa cli <== NOT EXECUTED 10e35d: 59 pop %ecx <== NOT EXECUTED /** 10e35e: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10e361: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10e364: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10e367: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 10e36a: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 10e36d: 51 push %ecx <== NOT EXECUTED 10e36e: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10e36f: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10e373: 74 0b je 10e380 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10e375: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e378: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10e37c: b3 01 mov $0x1,%bl <== NOT EXECUTED 10e37e: eb 02 jmp 10e382 <== NOT EXECUTED 10e380: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 10e382: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 10e389: 75 12 jne 10e39d <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10e38b: e8 58 01 00 00 call 10e4e8 <_Thread_Evaluate_mode> <== NOT EXECUTED 10e390: 84 c0 test %al,%al <== NOT EXECUTED 10e392: 75 04 jne 10e398 <== NOT EXECUTED 10e394: 84 db test %bl,%bl <== NOT EXECUTED 10e396: 74 05 je 10e39d <== NOT EXECUTED _Thread_Dispatch(); 10e398: e8 df c8 ff ff call 10ac7c <_Thread_Dispatch> <== NOT EXECUTED 10e39d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10e39f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e3a2: 5b pop %ebx <== NOT EXECUTED 10e3a3: 5e pop %esi <== NOT EXECUTED 10e3a4: 5f pop %edi <== NOT EXECUTED 10e3a5: c9 leave <== NOT EXECUTED 10e3a6: c3 ret <== NOT EXECUTED 00109dd0 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 109dd0: 55 push %ebp <== NOT EXECUTED 109dd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109dd3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 109dd6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109dd9: 50 push %eax <== NOT EXECUTED 109dda: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109ddd: e8 9a 19 00 00 call 10b77c <_Thread_Get> <== NOT EXECUTED 109de2: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 109de4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109de7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109dec: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 109df0: 75 26 jne 109e18 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 109df2: 50 push %eax <== NOT EXECUTED 109df3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109df6: 6a 00 push $0x0 <== NOT EXECUTED 109df8: 52 push %edx <== NOT EXECUTED 109df9: e8 e6 20 00 00 call 10bee4 <_Thread_Restart> <== NOT EXECUTED 109dfe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e01: 84 c0 test %al,%al <== NOT EXECUTED 109e03: 74 09 je 109e0e <== NOT EXECUTED _Thread_Enable_dispatch(); 109e05: e8 52 19 00 00 call 10b75c <_Thread_Enable_dispatch> <== NOT EXECUTED 109e0a: 31 c0 xor %eax,%eax <== NOT EXECUTED 109e0c: eb 0a jmp 109e18 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 109e0e: e8 49 19 00 00 call 10b75c <_Thread_Enable_dispatch> <== NOT EXECUTED 109e13: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109e18: c9 leave <== NOT EXECUTED 109e19: c3 ret <== NOT EXECUTED 0010a584 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 10a584: 55 push %ebp <== NOT EXECUTED 10a585: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a587: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10a58a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a58d: 50 push %eax <== NOT EXECUTED 10a58e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a591: e8 f6 1b 00 00 call 10c18c <_Thread_Get> <== NOT EXECUTED 10a596: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a598: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a59b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a5a0: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10a5a4: 75 26 jne 10a5cc <== NOT EXECUTED case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10a5a6: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 10a5aa: 74 16 je 10a5c2 <== NOT EXECUTED _Thread_Resume( the_thread, TRUE ); 10a5ac: 50 push %eax <== NOT EXECUTED 10a5ad: 50 push %eax <== NOT EXECUTED 10a5ae: 6a 01 push $0x1 <== NOT EXECUTED 10a5b0: 52 push %edx <== NOT EXECUTED 10a5b1: e8 3e 23 00 00 call 10c8f4 <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a5b6: e8 85 1b 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a5bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a5bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5c0: eb 0a jmp 10a5cc <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a5c2: e8 79 1b 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a5c7: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a5cc: c9 leave <== NOT EXECUTED 10a5cd: c3 ret <== NOT EXECUTED 00121278 : #include #include rtems_id rtems_task_self(void) { 121278: 55 push %ebp <== NOT EXECUTED 121279: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12127b: a1 b4 9c 15 00 mov 0x159cb4,%eax <== NOT EXECUTED 121280: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 121283: c9 leave <== NOT EXECUTED 121284: c3 ret <== NOT EXECUTED 0010ab6c : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10ab6c: 55 push %ebp <== NOT EXECUTED 10ab6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab6f: 56 push %esi <== NOT EXECUTED 10ab70: 53 push %ebx <== NOT EXECUTED 10ab71: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ab74: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ab77: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ab7a: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10ab7d: a1 ac 07 12 00 mov 0x1207ac,%eax <== NOT EXECUTED 10ab82: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10ab85: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10ab8a: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10ab8e: 74 54 je 10abe4 <== 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 ) 10ab90: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10ab95: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10ab98: 77 4a ja 10abe4 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ab9a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab9c: 74 0a je 10aba8 <== NOT EXECUTED 10ab9e: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aba3: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10aba6: 75 11 jne 10abb9 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10aba8: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10abad: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10abb3: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED 10abb7: eb 29 jmp 10abe2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10abb9: 50 push %eax <== NOT EXECUTED 10abba: 50 push %eax <== NOT EXECUTED 10abbb: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abbe: 50 push %eax <== NOT EXECUTED 10abbf: 51 push %ecx <== NOT EXECUTED 10abc0: e8 df 1a 00 00 call 10c6a4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10abc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abc8: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10abcd: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10abd1: 75 11 jne 10abe4 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10abd3: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10abd9: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10abdd: e8 a2 1a 00 00 call 10c684 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abe2: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10abe4: 89 d0 mov %edx,%eax <== NOT EXECUTED 10abe6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10abe9: 5b pop %ebx <== NOT EXECUTED 10abea: 5e pop %esi <== NOT EXECUTED 10abeb: c9 leave <== NOT EXECUTED 10abec: c3 ret <== NOT EXECUTED 0010ca18 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10ca18: 55 push %ebp <== NOT EXECUTED 10ca19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca1b: 56 push %esi <== NOT EXECUTED 10ca1c: 53 push %ebx <== NOT EXECUTED 10ca1d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca20: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ca23: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10ca26: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca28: 74 10 je 10ca3a <== NOT EXECUTED 10ca2a: 0f b6 05 24 34 12 00 movzbl 0x123424,%eax <== NOT EXECUTED 10ca31: ba 13 00 00 00 mov $0x13,%edx <== NOT EXECUTED 10ca36: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ca38: 77 52 ja 10ca8c <== NOT EXECUTED !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10ca3a: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10ca3f: 85 f6 test %esi,%esi <== NOT EXECUTED 10ca41: 74 49 je 10ca8c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10ca43: 52 push %edx <== NOT EXECUTED 10ca44: 52 push %edx <== NOT EXECUTED 10ca45: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10ca48: 50 push %eax <== NOT EXECUTED 10ca49: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca4c: e8 37 1a 00 00 call 10e488 <_Thread_Get> <== NOT EXECUTED 10ca51: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10ca53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca56: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10ca5b: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10ca5f: 75 2b jne 10ca8c <== NOT EXECUTED case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10ca61: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ca64: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10ca66: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca68: 74 1b je 10ca85 <== NOT EXECUTED the_thread->real_priority = new_priority; 10ca6a: 89 59 18 mov %ebx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10ca6d: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 10ca71: 74 05 je 10ca78 <== NOT EXECUTED 10ca73: 39 59 14 cmp %ebx,0x14(%ecx) <== NOT EXECUTED 10ca76: 76 0d jbe 10ca85 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10ca78: 50 push %eax <== NOT EXECUTED 10ca79: 6a 00 push $0x0 <== NOT EXECUTED 10ca7b: 53 push %ebx <== NOT EXECUTED 10ca7c: 51 push %ecx <== NOT EXECUTED 10ca7d: e8 1a 15 00 00 call 10df9c <_Thread_Change_priority> <== NOT EXECUTED 10ca82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10ca85: e8 b2 19 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca8a: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ca8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ca8e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca91: 5b pop %ebx <== NOT EXECUTED 10ca92: 5e pop %esi <== NOT EXECUTED 10ca93: c9 leave <== NOT EXECUTED 10ca94: c3 ret <== NOT EXECUTED 00109530 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 109530: 55 push %ebp <== NOT EXECUTED 109531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109533: 53 push %ebx <== NOT EXECUTED 109534: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109537: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10953a: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10953f: 85 db test %ebx,%ebx <== NOT EXECUTED 109541: 74 49 je 10958c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 109543: 50 push %eax <== NOT EXECUTED 109544: 50 push %eax <== NOT EXECUTED 109545: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109548: 50 push %eax <== NOT EXECUTED 109549: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10954c: e8 8f 18 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 109551: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 109553: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109556: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10955b: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10955f: 75 2b jne 10958c <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Start( 109561: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109564: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109567: 6a 00 push $0x0 <== NOT EXECUTED 109569: 53 push %ebx <== NOT EXECUTED 10956a: 6a 00 push $0x0 <== NOT EXECUTED 10956c: 52 push %edx <== NOT EXECUTED 10956d: e8 56 22 00 00 call 10b7c8 <_Thread_Start> <== NOT EXECUTED 109572: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109575: 84 c0 test %al,%al <== NOT EXECUTED 109577: 74 09 je 109582 <== NOT EXECUTED the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 109579: e8 42 18 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10957e: 31 c0 xor %eax,%eax <== NOT EXECUTED 109580: eb 0a jmp 10958c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 109582: e8 39 18 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109587: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10958c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10958f: c9 leave <== NOT EXECUTED 109590: c3 ret <== NOT EXECUTED 0010a634 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 10a634: 55 push %ebp <== NOT EXECUTED 10a635: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a637: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10a63a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a63d: 50 push %eax <== NOT EXECUTED 10a63e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a641: e8 46 1b 00 00 call 10c18c <_Thread_Get> <== NOT EXECUTED 10a646: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a648: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a64b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a650: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10a654: 75 25 jne 10a67b <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10a656: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 10a65a: 75 15 jne 10a671 <== NOT EXECUTED _Thread_Suspend( the_thread ); 10a65c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a65f: 52 push %edx <== NOT EXECUTED 10a660: e8 0f 26 00 00 call 10cc74 <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a665: e8 d6 1a 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a66a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a66c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a66f: eb 0a jmp 10a67b <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a671: e8 ca 1a 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a676: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a67b: c9 leave <== NOT EXECUTED 10a67c: c3 ret <== NOT EXECUTED 00121470 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 121470: 55 push %ebp <== NOT EXECUTED 121471: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121473: 57 push %edi <== NOT EXECUTED 121474: 56 push %esi <== NOT EXECUTED 121475: 53 push %ebx <== NOT EXECUTED 121476: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 121479: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12147c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12147f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121484: 85 f6 test %esi,%esi <== NOT EXECUTED 121486: 74 75 je 1214fd <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 121488: 50 push %eax <== NOT EXECUTED 121489: 50 push %eax <== NOT EXECUTED 12148a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12148d: 50 push %eax <== NOT EXECUTED 12148e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121491: e8 ca e4 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 121496: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 121498: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12149b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1214a0: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 1214a4: 75 57 jne 1214fd <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1214a6: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 1214ac: eb 0c jmp 1214ba <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 1214ae: 39 70 04 cmp %esi,0x4(%eax) <== NOT EXECUTED 1214b1: 75 05 jne 1214b8 <== NOT EXECUTED tvp->dtor = dtor; 1214b3: 89 78 10 mov %edi,0x10(%eax) <== NOT EXECUTED 1214b6: eb 3e jmp 1214f6 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1214b8: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 1214ba: 85 c0 test %eax,%eax <== NOT EXECUTED 1214bc: 75 f0 jne 1214ae <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1214be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1214c1: 6a 14 push $0x14 <== NOT EXECUTED 1214c3: e8 15 f4 fe ff call 1108dd <_Workspace_Allocate> <== NOT EXECUTED 1214c8: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1214ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1214cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1214cf: 75 0c jne 1214dd <== NOT EXECUTED _Thread_Enable_dispatch(); 1214d1: e8 6a e4 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1214d6: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 1214db: eb 20 jmp 1214fd <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 1214dd: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1214df: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 1214e2: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 1214e5: 89 7a 10 mov %edi,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 1214e8: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 1214ee: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 1214f0: 89 93 04 01 00 00 mov %edx,0x104(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1214f6: e8 45 e4 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1214fb: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1214fd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121500: 5b pop %ebx <== NOT EXECUTED 121501: 5e pop %esi <== NOT EXECUTED 121502: 5f pop %edi <== NOT EXECUTED 121503: c9 leave <== NOT EXECUTED 121504: c3 ret <== NOT EXECUTED 00121508 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 121508: 55 push %ebp <== NOT EXECUTED 121509: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12150b: 56 push %esi <== NOT EXECUTED 12150c: 53 push %ebx <== NOT EXECUTED 12150d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121510: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 121513: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121518: 85 f6 test %esi,%esi <== NOT EXECUTED 12151a: 74 64 je 121580 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 12151c: 52 push %edx <== NOT EXECUTED 12151d: 52 push %edx <== NOT EXECUTED 12151e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 121521: 50 push %eax <== NOT EXECUTED 121522: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121525: e8 36 e4 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 12152a: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 12152c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12152f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 121534: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 121538: 75 46 jne 121580 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 12153a: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx <== NOT EXECUTED 121540: 31 c0 xor %eax,%eax <== NOT EXECUTED 121542: eb 2e jmp 121572 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 121544: 39 72 04 cmp %esi,0x4(%edx) <== NOT EXECUTED 121547: 75 25 jne 12156e <== NOT EXECUTED if (prev) 121549: 85 c0 test %eax,%eax <== NOT EXECUTED 12154b: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 12154d: 74 04 je 121553 <== NOT EXECUTED prev->next = tvp->next; 12154f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 121551: eb 06 jmp 121559 <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 121553: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx) <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 121559: 50 push %eax <== NOT EXECUTED 12155a: 50 push %eax <== NOT EXECUTED 12155b: 52 push %edx <== NOT EXECUTED 12155c: 53 push %ebx <== NOT EXECUTED 12155d: e8 8e 00 00 00 call 1215f0 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 121562: e8 d9 e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 121567: 31 c0 xor %eax,%eax <== NOT EXECUTED 121569: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12156c: eb 12 jmp 121580 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 12156e: 89 d0 mov %edx,%eax <== NOT EXECUTED 121570: 8b 12 mov (%edx),%edx <== NOT EXECUTED the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 121572: 85 d2 test %edx,%edx <== NOT EXECUTED 121574: 75 ce jne 121544 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 121576: e8 c5 e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 12157b: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121580: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121583: 5b pop %ebx <== NOT EXECUTED 121584: 5e pop %esi <== NOT EXECUTED 121585: c9 leave <== NOT EXECUTED 121586: c3 ret <== NOT EXECUTED 00121588 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 121588: 55 push %ebp <== NOT EXECUTED 121589: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12158b: 56 push %esi <== NOT EXECUTED 12158c: 53 push %ebx <== NOT EXECUTED 12158d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121590: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 121593: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 121596: 85 db test %ebx,%ebx <== NOT EXECUTED 121598: 74 48 je 1215e2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 12159a: 85 f6 test %esi,%esi <== NOT EXECUTED 12159c: 74 44 je 1215e2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 12159e: 50 push %eax <== NOT EXECUTED 12159f: 50 push %eax <== NOT EXECUTED 1215a0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1215a3: 50 push %eax <== NOT EXECUTED 1215a4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1215a7: e8 b4 e3 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 1215ac: 89 c2 mov %eax,%edx <== NOT EXECUTED switch (location) { 1215ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1215b1: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1215b6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1215ba: 75 2b jne 1215e7 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 1215bc: 8b 82 04 01 00 00 mov 0x104(%edx),%eax <== NOT EXECUTED 1215c2: eb 15 jmp 1215d9 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 1215c4: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1215c7: 75 0e jne 1215d7 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 1215c9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 1215cc: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1215ce: e8 6d e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1215d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1215d5: eb 10 jmp 1215e7 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1215d7: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 1215d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1215db: 75 e7 jne 1215c4 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 1215dd: e8 5e e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 1215e2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1215e7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1215ea: 5b pop %ebx <== NOT EXECUTED 1215eb: 5e pop %esi <== NOT EXECUTED 1215ec: c9 leave <== NOT EXECUTED 1215ed: c3 ret <== NOT EXECUTED 00109594 : */ rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 109594: 55 push %ebp <== NOT EXECUTED 109595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109597: 53 push %ebx <== NOT EXECUTED 109598: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10959b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10959e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 1095a3: 40 inc %eax <== NOT EXECUTED 1095a4: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { 1095a9: 85 db test %ebx,%ebx <== NOT EXECUTED 1095ab: 75 07 jne 1095b4 <== NOT EXECUTED _Thread_Yield_processor(); 1095ad: e8 d6 22 00 00 call 10b888 <_Thread_Yield_processor> <== NOT EXECUTED 1095b2: eb 45 jmp 1095f9 <== NOT EXECUTED } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 1095b4: 50 push %eax <== NOT EXECUTED 1095b5: 50 push %eax <== NOT EXECUTED 1095b6: 6a 08 push $0x8 <== NOT EXECUTED 1095b8: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 1095be: e8 ed 1f 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 1095c3: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 1095c8: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 1095cb: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1095d2: c7 40 64 44 ac 10 00 movl $0x10ac44,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1095d9: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 1095dc: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 1095e3: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 1095e6: 5a pop %edx <== NOT EXECUTED 1095e7: 59 pop %ecx <== NOT EXECUTED 1095e8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1095eb: 50 push %eax <== NOT EXECUTED 1095ec: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 1095f1: e8 66 25 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 1095f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 1095f9: e8 c2 17 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1095fe: 31 c0 xor %eax,%eax <== NOT EXECUTED 109600: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109603: c9 leave <== NOT EXECUTED 109604: c3 ret <== NOT EXECUTED 0010a124 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10a124: 55 push %ebp <== NOT EXECUTED 10a125: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a127: 53 push %ebx <== NOT EXECUTED 10a128: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a12b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10a12e: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a133: 80 3d d8 f4 11 00 00 cmpb $0x0,0x11f4d8 <== NOT EXECUTED 10a13a: 0f 84 9e 00 00 00 je 10a1de <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10a140: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a145: 85 db test %ebx,%ebx <== NOT EXECUTED 10a147: 0f 84 91 00 00 00 je 10a1de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10a14d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED if ( !_TOD_Validate( time_buffer ) ) 10a154: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a157: 53 push %ebx <== NOT EXECUTED 10a158: e8 d7 f4 ff ff call 109634 <_TOD_Validate> <== NOT EXECUTED 10a15d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a160: 84 c0 test %al,%al <== NOT EXECUTED 10a162: 74 75 je 10a1d9 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10a164: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a167: 53 push %ebx <== NOT EXECUTED 10a168: e8 5f f4 ff ff call 1095cc <_TOD_To_seconds> <== NOT EXECUTED 10a16d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 10a16f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a172: 3b 05 54 f5 11 00 cmp 0x11f554,%eax <== NOT EXECUTED 10a178: 76 5f jbe 10a1d9 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a17a: a1 c4 f4 11 00 mov 0x11f4c4,%eax <== NOT EXECUTED 10a17f: 40 inc %eax <== NOT EXECUTED 10a180: a3 c4 f4 11 00 mov %eax,0x11f4c4 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10a185: 50 push %eax <== NOT EXECUTED 10a186: 50 push %eax <== NOT EXECUTED 10a187: 6a 10 push $0x10 <== NOT EXECUTED 10a189: ff 35 84 f5 11 00 pushl 0x11f584 <== NOT EXECUTED 10a18f: e8 84 20 00 00 call 10c218 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a194: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 10a199: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a19c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a1a3: c7 40 64 ac b8 10 00 movl $0x10b8ac,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a1aa: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10a1ad: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10a1b4: 2b 1d 54 f5 11 00 sub 0x11f554,%ebx <== NOT EXECUTED 10a1ba: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED size_t size ); 10a1bd: 5a pop %edx <== NOT EXECUTED 10a1be: 59 pop %ecx <== NOT EXECUTED 10a1bf: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10a1c2: 50 push %eax <== NOT EXECUTED 10a1c3: 68 98 f5 11 00 push $0x11f598 <== NOT EXECUTED 10a1c8: e8 63 26 00 00 call 10c830 <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10a1cd: e8 56 18 00 00 call 10ba28 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a1d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a1d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1d7: eb 05 jmp 10a1de <== NOT EXECUTED return RTEMS_SUCCESSFUL; 10a1d9: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED } 10a1de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a1e1: c9 leave <== NOT EXECUTED 10a1e2: c3 ret <== NOT EXECUTED 00107174 : rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) { 107174: 55 push %ebp <== NOT EXECUTED 107175: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_termios_cbufsize = cbufsize; 107177: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10717a: a3 3c a9 11 00 mov %eax,0x11a93c <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 10717f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107182: a3 40 a9 11 00 mov %eax,0x11a940 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107187: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10718a: a3 44 a9 11 00 mov %eax,0x11a944 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10718f: 31 c0 xor %eax,%eax <== NOT EXECUTED 107191: c9 leave <== NOT EXECUTED 107192: c3 ret <== NOT EXECUTED 00108312 : } } rtems_status_code rtems_termios_close (void *arg) { 108312: 55 push %ebp <== NOT EXECUTED 108313: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108315: 56 push %esi <== NOT EXECUTED 108316: 53 push %ebx <== NOT EXECUTED 108317: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10831a: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10831c: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10831f: 50 push %eax <== NOT EXECUTED 108320: 6a 00 push $0x0 <== NOT EXECUTED 108322: 6a 00 push $0x0 <== NOT EXECUTED 108324: ff 35 3c c9 11 00 pushl 0x11c93c <== NOT EXECUTED 10832a: e8 19 0e 00 00 call 109148 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 10832f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108332: 85 c0 test %eax,%eax <== NOT EXECUTED 108334: 75 69 jne 10839f <== NOT EXECUTED rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 108336: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 108339: 48 dec %eax <== NOT EXECUTED 10833a: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 10833d: 85 c0 test %eax,%eax <== NOT EXECUTED 10833f: 0f 85 1f 01 00 00 jne 108464 <== NOT EXECUTED if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108345: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10834b: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10834e: 8b 80 b8 c6 11 00 mov 0x11c6b8(%eax),%eax <== NOT EXECUTED 108354: 85 c0 test %eax,%eax <== NOT EXECUTED 108356: 74 0b je 108363 <== NOT EXECUTED /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108358: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10835b: 53 push %ebx <== NOT EXECUTED 10835c: ff d0 call *%eax <== NOT EXECUTED 10835e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108361: eb 07 jmp 10836a <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 108363: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108365: e8 ec f8 ff ff call 107c56 <== NOT EXECUTED } if (tty->device.outputUsesInterrupts 10836a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 108371: 75 35 jne 1083a8 <== NOT EXECUTED == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 108373: 50 push %eax <== NOT EXECUTED 108374: 50 push %eax <== NOT EXECUTED 108375: 6a 01 push $0x1 <== NOT EXECUTED 108377: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 10837d: e8 36 09 00 00 call 108cb8 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 108382: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108385: 85 c0 test %eax,%eax <== NOT EXECUTED 108387: 75 16 jne 10839f <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 108389: 51 push %ecx <== NOT EXECUTED 10838a: 51 push %ecx <== NOT EXECUTED 10838b: 6a 01 push $0x1 <== NOT EXECUTED 10838d: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 108393: e8 20 09 00 00 call 108cb8 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 108398: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10839b: 85 c0 test %eax,%eax <== NOT EXECUTED 10839d: 74 09 je 1083a8 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 10839f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1083a2: 50 push %eax <== NOT EXECUTED 1083a3: e8 b8 13 00 00 call 109760 <== NOT EXECUTED } if (tty->device.lastClose) 1083a8: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax <== NOT EXECUTED 1083ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1083b0: 74 0d je 1083bf <== NOT EXECUTED (*tty->device.lastClose)(tty->major, tty->minor, arg); 1083b2: 52 push %edx <== NOT EXECUTED 1083b3: 56 push %esi <== NOT EXECUTED 1083b4: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1083b7: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1083ba: ff d0 call *%eax <== NOT EXECUTED 1083bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (tty->forw == NULL) { 1083bf: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 1083c1: 85 d2 test %edx,%edx <== NOT EXECUTED 1083c3: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1083c6: 75 11 jne 1083d9 <== NOT EXECUTED rtems_termios_ttyTail = tty->back; 1083c8: a3 40 c9 11 00 mov %eax,0x11c940 <== NOT EXECUTED if ( rtems_termios_ttyTail != NULL ) { 1083cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1083cf: 74 0b je 1083dc <== NOT EXECUTED rtems_termios_ttyTail->forw = NULL; 1083d1: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1083d7: eb 03 jmp 1083dc <== NOT EXECUTED } } else { tty->forw->back = tty->back; 1083d9: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED } if (tty->back == NULL) { 1083dc: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 1083df: 85 d2 test %edx,%edx <== NOT EXECUTED 1083e1: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1083e3: 75 12 jne 1083f7 <== NOT EXECUTED rtems_termios_ttyHead = tty->forw; 1083e5: a3 44 c9 11 00 mov %eax,0x11c944 <== NOT EXECUTED if ( rtems_termios_ttyHead != NULL ) { 1083ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1083ec: 74 0b je 1083f9 <== NOT EXECUTED rtems_termios_ttyHead->back = NULL; 1083ee: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 1083f5: eb 02 jmp 1083f9 <== NOT EXECUTED } } else { tty->back->forw = tty->forw; 1083f7: 89 02 mov %eax,(%edx) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 1083f9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1083fc: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 1083ff: e8 b4 0c 00 00 call 1090b8 <== NOT EXECUTED rtems_semaphore_delete (tty->osem); 108404: 58 pop %eax <== NOT EXECUTED 108405: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 108408: e8 ab 0c 00 00 call 1090b8 <== NOT EXECUTED rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 10840d: 58 pop %eax <== NOT EXECUTED 10840e: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 108414: e8 9f 0c 00 00 call 1090b8 <== NOT EXECUTED if ((tty->device.pollRead == NULL) || 108419: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10841c: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) <== NOT EXECUTED 108423: 74 09 je 10842e <== NOT EXECUTED 108425: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 10842c: 75 0e jne 10843c <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 10842e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108431: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 108434: e8 7f 0c 00 00 call 1090b8 <== NOT EXECUTED 108439: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free (tty->rawInBuf.theBuf); 10843c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10843f: ff 73 58 pushl 0x58(%ebx) <== NOT EXECUTED 108442: e8 21 e0 ff ff call 106468 <== NOT EXECUTED free (tty->rawOutBuf.theBuf); 108447: 5e pop %esi <== NOT EXECUTED 108448: ff 73 7c pushl 0x7c(%ebx) <== NOT EXECUTED 10844b: e8 18 e0 ff ff call 106468 <== NOT EXECUTED free (tty->cbuf); 108450: 59 pop %ecx <== NOT EXECUTED 108451: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 108454: e8 0f e0 ff ff call 106468 <== NOT EXECUTED free (tty); 108459: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10845c: e8 07 e0 ff ff call 106468 <== NOT EXECUTED 108461: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (rtems_termios_ttyMutex); 108464: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108467: ff 35 3c c9 11 00 pushl 0x11c93c <== NOT EXECUTED 10846d: e8 be 0d 00 00 call 109230 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108472: 31 c0 xor %eax,%eax <== NOT EXECUTED 108474: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108477: 5b pop %ebx <== NOT EXECUTED 108478: 5e pop %esi <== NOT EXECUTED 108479: c9 leave <== NOT EXECUTED 10847a: c3 ret <== NOT EXECUTED 0010737b : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 10737b: 55 push %ebp <== NOT EXECUTED 10737c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10737e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107381: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 107384: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107387: 01 82 90 00 00 00 add %eax,0x90(%edx) <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10738d: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) <== NOT EXECUTED 107394: 75 1f jne 1073b5 <== NOT EXECUTED /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 107396: 50 push %eax <== NOT EXECUTED 107397: 50 push %eax <== NOT EXECUTED 107398: 6a 02 push $0x2 <== NOT EXECUTED 10739a: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED 1073a0: e8 13 19 00 00 call 108cb8 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 1073a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1073a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1073aa: 74 2f je 1073db <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1073ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1073af: 50 push %eax <== NOT EXECUTED 1073b0: e8 ab 23 00 00 call 109760 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { 1073b5: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx) <== NOT EXECUTED 1073bc: 75 14 jne 1073d2 <== NOT EXECUTED /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1073be: a1 68 c7 11 00 mov 0x11c768,%eax <== NOT EXECUTED 1073c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1073c5: 74 14 je 1073db <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 1073c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1073ca: 52 push %edx <== NOT EXECUTED 1073cb: ff d0 call *%eax <== NOT EXECUTED 1073cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1073d0: eb 09 jmp 1073db <== NOT EXECUTED } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 1073d2: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 1073d5: c9 leave <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 1073d6: e9 d3 fd ff ff jmp 1071ae <== NOT EXECUTED } } 1073db: 31 c0 xor %eax,%eax <== NOT EXECUTED 1073dd: c9 leave <== NOT EXECUTED 1073de: c3 ret <== NOT EXECUTED 001073df : * 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) { 1073df: 55 push %ebp <== NOT EXECUTED 1073e0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1073e2: 57 push %edi <== NOT EXECUTED 1073e3: 56 push %esi <== NOT EXECUTED 1073e4: 53 push %ebx <== NOT EXECUTED 1073e5: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1073e8: 8b 5d 08 mov 0x8(%ebp),%ebx <== 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) { 1073eb: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1073f1: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1073f4: 83 b8 c4 c6 11 00 00 cmpl $0x0,0x11c6c4(%eax) <== NOT EXECUTED 1073fb: 75 37 jne 107434 <== 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, 1073fd: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 107400: 89 45 e4 mov %eax,-0x1c(%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); 107403: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 107406: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 107409: 31 ff xor %edi,%edi <== NOT EXECUTED 10740b: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED 10740f: e9 27 02 00 00 jmp 10763b <== NOT EXECUTED 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--) { c = *buf++; 107414: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 107417: 0f be 11 movsbl (%ecx),%edx <== NOT EXECUTED 10741a: 41 inc %ecx <== NOT EXECUTED 10741b: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10741e: 56 push %esi <== NOT EXECUTED 10741f: 56 push %esi <== NOT EXECUTED 107420: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 107426: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107429: 53 push %ebx <== NOT EXECUTED 10742a: 52 push %edx <== NOT EXECUTED 10742b: ff 90 c4 c6 11 00 call *0x11c6c4(%eax) <== NOT EXECUTED 107431: 83 c4 10 add $0x10,%esp <== 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--) { 107434: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED 107437: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED 10743b: 75 d7 jne 107414 <== NOT EXECUTED } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10743d: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 107444: 0f 85 11 02 00 00 jne 10765b <== NOT EXECUTED 10744a: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx <== NOT EXECUTED 107450: 85 d2 test %edx,%edx <== NOT EXECUTED 107452: 0f 84 03 02 00 00 je 10765b <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 107458: 51 push %ecx <== NOT EXECUTED 107459: 51 push %ecx <== NOT EXECUTED 10745a: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 107460: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 107463: 50 push %eax <== NOT EXECUTED 107464: ff d2 call *%edx <== NOT EXECUTED tty->tty_rcvwakeup = 1; 107466: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10746d: 00 00 00 <== NOT EXECUTED 107470: 31 ff xor %edi,%edi <== NOT EXECUTED 107472: e9 df 01 00 00 jmp 107656 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 107477: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10747a: 8a 00 mov (%eax),%al <== NOT EXECUTED 10747c: 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) { 10747f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107485: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 107488: 74 43 je 1074cd <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 10748a: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED 10748e: 0f b6 43 4a movzbl 0x4a(%ebx),%eax <== NOT EXECUTED 107492: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107494: 75 1e jne 1074b4 <== NOT EXECUTED if (c == tty->termios.c_cc[VSTART]) { 107496: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED 10749a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10749c: 75 0b jne 1074a9 <== NOT EXECUTED /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 10749e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074a4: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 1074a7: eb 1c jmp 1074c5 <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 1074a9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074af: 83 c8 10 or $0x10,%eax <== NOT EXECUTED 1074b2: eb 11 jmp 1074c5 <== NOT EXECUTED } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 1074b4: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED 1074b8: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1074ba: 75 11 jne 1074cd <== NOT EXECUTED /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 1074bc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074c2: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 1074c5: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 1074cb: eb 06 jmp 1074d3 <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 1074cd: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED 1074d1: 74 55 je 107528 <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 1074d3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074d9: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 1074dc: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 1074e0: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 1074e3: 0f 85 4f 01 00 00 jne 107638 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 1074e9: 9c pushf <== NOT EXECUTED 1074ea: fa cli <== NOT EXECUTED 1074eb: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1074ec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074f2: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1074f5: 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) { 1074fb: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 107502: 74 19 je 10751d <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 107504: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 10750a: 52 push %edx <== NOT EXECUTED 10750b: 6a 01 push $0x1 <== NOT EXECUTED 10750d: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 107510: 50 push %eax <== NOT EXECUTED 107511: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107514: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10751a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 10751d: 56 push %esi <== NOT EXECUTED 10751e: 9d popf <== NOT EXECUTED 10751f: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 107523: e9 10 01 00 00 jmp 107638 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 107528: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 10752b: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 10752e: 40 inc %eax <== NOT EXECUTED 10752f: 31 d2 xor %edx,%edx <== NOT EXECUTED 107531: f7 f1 div %ecx <== NOT EXECUTED 107533: 89 d6 mov %edx,%esi <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 107535: 9c pushf <== NOT EXECUTED 107536: fa cli <== NOT EXECUTED 107537: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10753a: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED 10753d: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 107540: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 107543: 29 c8 sub %ecx,%eax <== NOT EXECUTED 107545: 01 f0 add %esi,%eax <== NOT EXECUTED 107547: 89 d1 mov %edx,%ecx <== NOT EXECUTED 107549: 31 d2 xor %edx,%edx <== NOT EXECUTED 10754b: f7 f1 div %ecx <== NOT EXECUTED 10754d: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx <== NOT EXECUTED 107553: 0f 86 98 00 00 00 jbe 1075f1 <== NOT EXECUTED 107559: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10755f: a8 01 test $0x1,%al <== NOT EXECUTED 107561: 0f 85 8a 00 00 00 jne 1075f1 <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 107567: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10756d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 107570: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 107576: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10757c: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 107581: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 107586: 75 33 jne 1075bb <== NOT EXECUTED == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || 107588: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10758e: a8 20 test $0x20,%al <== NOT EXECUTED 107590: 75 09 jne 10759b <== NOT EXECUTED 107592: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 107599: 75 56 jne 1075f1 <== 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; 10759b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075a1: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1075a4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 1075aa: 51 push %ecx <== NOT EXECUTED 1075ab: 6a 01 push $0x1 <== NOT EXECUTED 1075ad: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1075b0: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1075b3: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1075b9: eb 33 jmp 1075ee <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 1075bb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075c1: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 1075c6: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 1075cb: 75 24 jne 1075f1 <== NOT EXECUTED == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 1075cd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075d3: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 1075d6: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 1075dc: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 1075e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1075e4: 74 0b je 1075f1 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 1075e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1075e9: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1075ec: ff d0 call *%eax <== NOT EXECUTED 1075ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 1075f1: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1075f4: 9d popf <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 1075f5: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 1075f8: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1075fa: 75 03 jne 1075ff <== NOT EXECUTED dropped++; 1075fc: 47 inc %edi <== NOT EXECUTED 1075fd: eb 39 jmp 107638 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 1075ff: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 107602: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED 107605: 88 14 30 mov %dl,(%eax,%esi,1) <== NOT EXECUTED tty->rawInBuf.Tail = newTail; 107608: 89 73 60 mov %esi,0x60(%ebx) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10760b: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 107612: 75 24 jne 107638 <== NOT EXECUTED 107614: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED 10761a: 85 c0 test %eax,%eax <== NOT EXECUTED 10761c: 74 1a je 107638 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10761e: 52 push %edx <== NOT EXECUTED 10761f: 52 push %edx <== NOT EXECUTED 107620: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 107626: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107629: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 10762b: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 107632: 00 00 00 <== NOT EXECUTED 107635: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 107638: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10763b: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED 10763e: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED 107642: 0f 85 2f fe ff ff jne 107477 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 107648: 01 7b 78 add %edi,0x78(%ebx) <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 10764b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10764e: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 107651: e8 da 1b 00 00 call 109230 <== NOT EXECUTED 107656: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107659: eb 02 jmp 10765d <== NOT EXECUTED return dropped; 10765b: 31 ff xor %edi,%edi <== NOT EXECUTED } 10765d: 89 f8 mov %edi,%eax <== NOT EXECUTED 10765f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107662: 5b pop %ebx <== NOT EXECUTED 107663: 5e pop %esi <== NOT EXECUTED 107664: 5f pop %edi <== NOT EXECUTED 107665: c9 leave <== NOT EXECUTED 107666: c3 ret <== NOT EXECUTED 00107138 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 107138: 55 push %ebp <== NOT EXECUTED 107139: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10713b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 10713e: 83 3d 3c c9 11 00 00 cmpl $0x0,0x11c93c <== NOT EXECUTED 107145: 75 28 jne 10716f <== NOT EXECUTED sc = rtems_semaphore_create ( 107147: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10714a: 68 3c c9 11 00 push $0x11c93c <== NOT EXECUTED 10714f: 6a 00 push $0x0 <== NOT EXECUTED 107151: 6a 54 push $0x54 <== NOT EXECUTED 107153: 6a 01 push $0x1 <== NOT EXECUTED 107155: 68 69 6d 52 54 push $0x54526d69 <== NOT EXECUTED 10715a: e8 b5 1d 00 00 call 108f14 <== NOT EXECUTED rtems_build_name ('T', 'R', 'm', 'i'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) 10715f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107162: 85 c0 test %eax,%eax <== NOT EXECUTED 107164: 74 09 je 10716f <== NOT EXECUTED rtems_fatal_error_occurred (sc); 107166: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107169: 50 push %eax <== NOT EXECUTED 10716a: e8 f1 25 00 00 call 109760 <== NOT EXECUTED } } 10716f: c9 leave <== NOT EXECUTED 107170: c3 ret <== NOT EXECUTED 00107fbd : } } rtems_status_code rtems_termios_ioctl (void *arg) { 107fbd: 55 push %ebp <== NOT EXECUTED 107fbe: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107fc0: 57 push %edi <== NOT EXECUTED 107fc1: 56 push %esi <== NOT EXECUTED 107fc2: 53 push %ebx <== NOT EXECUTED 107fc3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107fc6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107fc9: 8b 02 mov (%edx),%eax <== NOT EXECUTED 107fcb: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 107fce: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED rtems_status_code sc; args->ioctl_return = 0; 107fd1: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107fd8: 6a 00 push $0x0 <== NOT EXECUTED 107fda: 6a 00 push $0x0 <== NOT EXECUTED 107fdc: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 107fdf: e8 64 11 00 00 call 109148 <== NOT EXECUTED 107fe4: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 107fe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107fea: 85 c0 test %eax,%eax <== NOT EXECUTED 107fec: 74 0b je 107ff9 <== NOT EXECUTED args->ioctl_return = sc; 107fee: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 107ff1: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 107ff4: e9 0e 03 00 00 jmp 108307 <== NOT EXECUTED return sc; } switch (args->command) { 107ff9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107ffc: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 107fff: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 108002: 0f 84 56 02 00 00 je 10825e <== NOT EXECUTED 108008: 77 10 ja 10801a <== NOT EXECUTED 10800a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10800d: 74 75 je 108084 <== NOT EXECUTED 10800f: 0f 87 27 02 00 00 ja 10823c <== NOT EXECUTED 108015: 48 dec %eax <== NOT EXECUTED 108016: 75 2f jne 108047 <== NOT EXECUTED 108018: eb 55 jmp 10806f <== NOT EXECUTED 10801a: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED 10801f: 0f 84 ae 02 00 00 je 1082d3 <== NOT EXECUTED 108025: 77 0a ja 108031 <== NOT EXECUTED 108027: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10802a: 75 1b jne 108047 <== NOT EXECUTED 10802c: e9 17 02 00 00 jmp 108248 <== NOT EXECUTED 108031: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED 108036: 0f 84 87 02 00 00 je 1082c3 <== NOT EXECUTED 10803c: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED 108041: 0f 84 2a 02 00 00 je 108271 <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108047: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10804d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108050: 8b 80 cc c6 11 00 mov 0x11c6cc(%eax),%eax <== NOT EXECUTED 108056: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 10805d: 85 c0 test %eax,%eax <== NOT EXECUTED 10805f: 0f 84 8b 02 00 00 je 1082f0 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 108065: 52 push %edx <== NOT EXECUTED 108066: 52 push %edx <== NOT EXECUTED 108067: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10806a: e9 49 02 00 00 jmp 1082b8 <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 10806f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108072: 8b 79 08 mov 0x8(%ecx),%edi <== NOT EXECUTED 108075: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED 108078: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 10807d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10807f: e9 6c 02 00 00 jmp 1082f0 <== NOT EXECUTED break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 108084: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108087: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED 10808a: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 10808d: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 108092: 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) && 108094: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10809a: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 10809d: 74 57 je 1080f6 <== NOT EXECUTED 10809f: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 1080a3: 75 51 jne 1080f6 <== NOT EXECUTED !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 1080a5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080ab: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 1080b0: 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) { 1080b6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080bc: a8 20 test $0x20,%al <== NOT EXECUTED 1080be: 74 36 je 1080f6 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 1080c0: 9c pushf <== NOT EXECUTED 1080c1: fa cli <== NOT EXECUTED 1080c2: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1080c3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080c9: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1080cc: 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) { 1080d2: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1080d9: 74 19 je 1080f4 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 1080db: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 1080e1: 57 push %edi <== NOT EXECUTED 1080e2: 6a 01 push $0x1 <== NOT EXECUTED 1080e4: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1080e7: 50 push %eax <== NOT EXECUTED 1080e8: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1080eb: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1080f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1080f4: 56 push %esi <== NOT EXECUTED 1080f5: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 1080f6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080fc: f6 c4 04 test $0x4,%ah <== NOT EXECUTED 1080ff: 74 24 je 108125 <== NOT EXECUTED 108101: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 108105: 75 1e jne 108125 <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 108107: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10810d: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 108110: 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); 108116: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10811c: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 10811f: 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) && 108125: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10812b: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 10812e: 74 43 je 108173 <== NOT EXECUTED 108130: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 108134: 78 3d js 108173 <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 108136: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10813c: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 10813f: 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) && 108145: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10814b: a8 04 test $0x4,%al <== NOT EXECUTED 10814d: 74 15 je 108164 <== NOT EXECUTED 10814f: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 108155: 85 c0 test %eax,%eax <== NOT EXECUTED 108157: 74 0b je 108164 <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 108159: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10815c: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10815f: ff d0 call *%eax <== NOT EXECUTED 108161: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 108164: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10816a: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10816d: 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) { 108173: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 108177: 79 0f jns 108188 <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; 108179: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10817f: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 108182: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 108188: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 10818c: 74 0f je 10819d <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 10818e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108194: 80 cc 04 or $0x4,%ah <== NOT EXECUTED 108197: 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) { 10819d: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 1081a1: 74 0f je 1081b2 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 1081a3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081a9: 80 cc 02 or $0x2,%ah <== NOT EXECUTED 1081ac: 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) { 1081b2: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 1081b6: 75 45 jne 1081fd <== 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); 1081b8: 56 push %esi <== NOT EXECUTED 1081b9: 56 push %esi <== NOT EXECUTED 1081ba: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1081bd: 50 push %eax <== NOT EXECUTED 1081be: 6a 03 push $0x3 <== NOT EXECUTED 1081c0: e8 93 07 00 00 call 108958 <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 1081c5: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED 1081c9: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED 1081cd: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 1081d2: 31 d2 xor %edx,%edx <== NOT EXECUTED 1081d4: f7 f1 div %ecx <== NOT EXECUTED 1081d6: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 1081d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1081dc: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 1081e0: 74 15 je 1081f7 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1081e2: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 1081e9: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) 1081ec: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 1081f0: 75 19 jne 10820b <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 1081f2: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED 1081f5: eb 24 jmp 10821b <== NOT EXECUTED } else { if (tty->termios.c_cc[VMIN]) { 1081f7: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 1081fb: 74 17 je 108214 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1081fd: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 108204: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 10820b: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED 108212: eb 07 jmp 10821b <== NOT EXECUTED } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 108214: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED } } } if (tty->device.setAttributes) 10821b: 8b 93 a8 00 00 00 mov 0xa8(%ebx),%edx <== NOT EXECUTED 108221: 85 d2 test %edx,%edx <== NOT EXECUTED 108223: 0f 84 c7 00 00 00 je 1082f0 <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 108229: 51 push %ecx <== NOT EXECUTED 10822a: 51 push %ecx <== NOT EXECUTED 10822b: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 10822e: 50 push %eax <== NOT EXECUTED 10822f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108232: ff d2 call *%edx <== NOT EXECUTED 108234: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108237: e9 b4 00 00 00 jmp 1082f0 <== NOT EXECUTED break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 10823c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10823e: e8 13 fa ff ff call 107c56 <== NOT EXECUTED 108243: e9 a8 00 00 00 jmp 1082f0 <== NOT EXECUTED break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108248: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10824a: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10824d: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 108253: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED 108259: e9 92 00 00 00 jmp 1082f0 <== NOT EXECUTED break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 10825e: 8b 16 mov (%esi),%edx <== NOT EXECUTED 108260: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 108263: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED 108269: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED 10826f: eb 7f jmp 1082f0 <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108271: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108277: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10827a: 8b 80 b8 c6 11 00 mov 0x11c6b8(%eax),%eax <== NOT EXECUTED 108280: 85 c0 test %eax,%eax <== NOT EXECUTED 108282: 74 0c je 108290 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108284: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108287: 53 push %ebx <== NOT EXECUTED 108288: ff d0 call *%eax <== NOT EXECUTED 10828a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10828d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 108290: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108293: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 108296: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108298: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 10829e: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 1082a5: 00 00 00 <== NOT EXECUTED /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 1082a8: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1082ab: 8b 80 b4 c6 11 00 mov 0x11c6b4(%eax),%eax <== NOT EXECUTED 1082b1: 85 c0 test %eax,%eax <== NOT EXECUTED 1082b3: 74 3b je 1082f0 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1082b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1082b8: 53 push %ebx <== NOT EXECUTED 1082b9: ff d0 call *%eax <== NOT EXECUTED 1082bb: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1082be: e9 71 ff ff ff jmp 108234 <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 1082c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1082c6: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 1082c9: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1082cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1082d1: eb 1d jmp 1082f0 <== NOT EXECUTED break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 1082d3: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED 1082d6: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( rawnc < 0 ) 1082d9: 29 c2 sub %eax,%edx <== NOT EXECUTED 1082db: 79 05 jns 1082e2 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 1082dd: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 1082e0: 01 c2 add %eax,%edx <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 1082e2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1082e5: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 1082e8: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED 1082eb: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED 1082ee: 89 10 mov %edx,(%eax) <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 1082f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1082f3: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 1082f6: e8 35 0f 00 00 call 109230 <== NOT EXECUTED args->ioctl_return = sc; 1082fb: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 1082fe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108301: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 108304: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 108307: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10830a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10830d: 5b pop %ebx <== NOT EXECUTED 10830e: 5e pop %esi <== NOT EXECUTED 10830f: 5f pop %edi <== NOT EXECUTED 108310: c9 leave <== NOT EXECUTED 108311: c3 ret <== NOT EXECUTED 0010847b : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 10847b: 55 push %ebp <== NOT EXECUTED 10847c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10847e: 57 push %edi <== NOT EXECUTED 10847f: 56 push %esi <== NOT EXECUTED 108480: 53 push %ebx <== NOT EXECUTED 108481: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, 108484: 6a 00 push $0x0 <== NOT EXECUTED 108486: 6a 00 push $0x0 <== NOT EXECUTED 108488: ff 35 3c c9 11 00 pushl 0x11c93c <== NOT EXECUTED 10848e: e8 b5 0c 00 00 call 109148 <== NOT EXECUTED 108493: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108496: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108499: 85 c0 test %eax,%eax <== NOT EXECUTED 10849b: 0f 85 c0 03 00 00 jne 108861 <== NOT EXECUTED return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1084a1: a1 44 c9 11 00 mov 0x11c944,%eax <== NOT EXECUTED 1084a6: eb 1c jmp 1084c4 <== NOT EXECUTED if ((tty->major == major) && (tty->minor == minor)) 1084a8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1084ab: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1084ae: 39 4a 0c cmp %ecx,0xc(%edx) <== NOT EXECUTED 1084b1: 75 0c jne 1084bf <== NOT EXECUTED 1084b3: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1084b6: 39 72 10 cmp %esi,0x10(%edx) <== NOT EXECUTED 1084b9: 0f 84 14 03 00 00 je 1087d3 <== NOT EXECUTED */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1084bf: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1084c2: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1084c4: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1084c7: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) <== NOT EXECUTED 1084cb: 75 db jne 1084a8 <== NOT EXECUTED 1084cd: e9 9a 03 00 00 jmp 10886c <== NOT EXECUTED /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 1084d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1084d5: e9 9d 00 00 00 jmp 108577 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 1084da: a1 40 a9 11 00 mov 0x11a940,%eax <== NOT EXECUTED 1084df: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1084e2: 89 42 64 mov %eax,0x64(%edx) <== NOT EXECUTED tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 1084e5: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 1084e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1084eb: 50 push %eax <== NOT EXECUTED 1084ec: e8 73 e1 ff ff call 106664 <== NOT EXECUTED 1084f1: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 1084f4: 89 41 58 mov %eax,0x58(%ecx) <== NOT EXECUTED if (tty->rawInBuf.theBuf == NULL) { 1084f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1084fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1084fc: 75 06 jne 108504 <== NOT EXECUTED free(tty); 1084fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108501: 51 push %ecx <== NOT EXECUTED 108502: eb 6d jmp 108571 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 108504: a1 44 a9 11 00 mov 0x11a944,%eax <== NOT EXECUTED 108509: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10850c: 89 86 88 00 00 00 mov %eax,0x88(%esi) <== NOT EXECUTED tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 108512: 8b 86 88 00 00 00 mov 0x88(%esi),%eax <== NOT EXECUTED 108518: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10851b: 50 push %eax <== NOT EXECUTED 10851c: e8 43 e1 ff ff call 106664 <== NOT EXECUTED 108521: 89 46 7c mov %eax,0x7c(%esi) <== NOT EXECUTED if (tty->rawOutBuf.theBuf == NULL) { 108524: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108527: 85 c0 test %eax,%eax <== NOT EXECUTED 108529: 75 10 jne 10853b <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 10852b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10852e: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED 108531: e8 32 df ff ff call 106468 <== NOT EXECUTED free(tty); 108536: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 108539: eb 36 jmp 108571 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 10853b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10853e: ff 35 3c a9 11 00 pushl 0x11a93c <== NOT EXECUTED 108544: e8 1b e1 ff ff call 106664 <== NOT EXECUTED 108549: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10854c: 89 42 1c mov %eax,0x1c(%edx) <== NOT EXECUTED if (tty->cbuf == NULL) { 10854f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108552: 85 c0 test %eax,%eax <== NOT EXECUTED 108554: 75 38 jne 10858e <== NOT EXECUTED free((void *)(tty->rawOutBuf.theBuf)); 108556: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108559: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED 10855c: e8 07 df ff ff call 106468 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 108561: 58 pop %eax <== NOT EXECUTED 108562: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108565: ff 71 58 pushl 0x58(%ecx) <== NOT EXECUTED 108568: e8 fb de ff ff call 106468 <== NOT EXECUTED free(tty); 10856d: 58 pop %eax <== NOT EXECUTED 10856e: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 108571: e8 f2 de ff ff call 106468 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 108576: 5f pop %edi <== NOT EXECUTED 108577: ff 35 3c c9 11 00 pushl 0x11c93c <== NOT EXECUTED 10857d: e8 ae 0c 00 00 call 109230 <== NOT EXECUTED 108582: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 108589: e9 d0 02 00 00 jmp 10885e <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 10858e: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 108591: c7 86 d4 00 00 00 00 movl $0x0,0xd4(%esi) <== NOT EXECUTED 108598: 00 00 00 <== NOT EXECUTED tty->tty_snd.sw_arg = NULL; 10859b: c7 86 d8 00 00 00 00 movl $0x0,0xd8(%esi) <== NOT EXECUTED 1085a2: 00 00 00 <== NOT EXECUTED tty->tty_rcv.sw_pfn = NULL; 1085a5: c7 86 dc 00 00 00 00 movl $0x0,0xdc(%esi) <== NOT EXECUTED 1085ac: 00 00 00 <== NOT EXECUTED tty->tty_rcv.sw_arg = NULL; 1085af: c7 86 e0 00 00 00 00 movl $0x0,0xe0(%esi) <== NOT EXECUTED 1085b6: 00 00 00 <== NOT EXECUTED tty->tty_rcvwakeup = 0; 1085b9: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 1085c0: 00 00 00 <== NOT EXECUTED /* * link tty */ tty->forw = rtems_termios_ttyHead; 1085c3: a1 44 c9 11 00 mov 0x11c944,%eax <== NOT EXECUTED 1085c8: 89 06 mov %eax,(%esi) <== NOT EXECUTED tty->back = NULL; 1085ca: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED if (rtems_termios_ttyHead != NULL) 1085d1: 85 c0 test %eax,%eax <== NOT EXECUTED 1085d3: 74 03 je 1085d8 <== NOT EXECUTED rtems_termios_ttyHead->back = tty; 1085d5: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED rtems_termios_ttyHead = tty; 1085d8: 89 1d 44 c9 11 00 mov %ebx,0x11c944 <== NOT EXECUTED if (rtems_termios_ttyTail == NULL) 1085de: 83 3d 40 c9 11 00 00 cmpl $0x0,0x11c940 <== NOT EXECUTED 1085e5: 75 06 jne 1085ed <== NOT EXECUTED rtems_termios_ttyTail = tty; 1085e7: 89 1d 40 c9 11 00 mov %ebx,0x11c940 <== NOT EXECUTED tty->minor = minor; 1085ed: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1085f0: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED tty->major = major; 1085f3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1085f6: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1085f9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1085fc: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1085ff: 50 push %eax <== NOT EXECUTED 108600: 6a 00 push $0x0 <== NOT EXECUTED 108602: 6a 54 push $0x54 <== NOT EXECUTED 108604: 6a 01 push $0x1 <== NOT EXECUTED 108606: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 10860d: 0d 00 69 52 54 or $0x54526900,%eax <== NOT EXECUTED 108612: 50 push %eax <== NOT EXECUTED 108613: e8 fc 08 00 00 call 108f14 <== NOT EXECUTED rtems_build_name ('T', 'R', 'i', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) 108618: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10861b: 85 c0 test %eax,%eax <== NOT EXECUTED 10861d: 0f 85 24 02 00 00 jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 108623: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108626: 8d 43 18 lea 0x18(%ebx),%eax <== NOT EXECUTED 108629: 50 push %eax <== NOT EXECUTED 10862a: 6a 00 push $0x0 <== NOT EXECUTED 10862c: 6a 54 push $0x54 <== NOT EXECUTED 10862e: 6a 01 push $0x1 <== NOT EXECUTED 108630: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 108637: 0d 00 6f 52 54 or $0x54526f00,%eax <== NOT EXECUTED 10863c: 50 push %eax <== NOT EXECUTED 10863d: e8 d2 08 00 00 call 108f14 <== NOT EXECUTED rtems_build_name ('T', 'R', 'o', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) 108642: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108645: 85 c0 test %eax,%eax <== NOT EXECUTED 108647: 0f 85 fa 01 00 00 jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10864d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108650: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax <== NOT EXECUTED 108656: 50 push %eax <== NOT EXECUTED 108657: 6a 00 push $0x0 <== NOT EXECUTED 108659: 6a 20 push $0x20 <== NOT EXECUTED 10865b: 6a 00 push $0x0 <== NOT EXECUTED 10865d: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 108664: 0d 00 78 52 54 or $0x54527800,%eax <== NOT EXECUTED 108669: 50 push %eax <== NOT EXECUTED 10866a: e8 a5 08 00 00 call 108f14 <== NOT EXECUTED rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 10866f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108672: 85 c0 test %eax,%eax <== NOT EXECUTED 108674: 0f 85 cd 01 00 00 jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 10867a: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) <== NOT EXECUTED 108681: 00 00 00 <== NOT EXECUTED /* * Set callbacks */ tty->device = *callbacks; 108684: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi <== NOT EXECUTED 10868a: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10868f: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 108692: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108694: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 10869b: 75 68 jne 108705 <== NOT EXECUTED sc = rtems_task_create ( 10869d: 56 push %esi <== NOT EXECUTED 10869e: 56 push %esi <== NOT EXECUTED 10869f: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax <== NOT EXECUTED 1086a5: 50 push %eax <== NOT EXECUTED 1086a6: 6a 00 push $0x0 <== NOT EXECUTED 1086a8: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1086ad: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1086b2: 6a 0a push $0xa <== NOT EXECUTED 1086b4: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 1086bb: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED 1086c0: 50 push %eax <== NOT EXECUTED 1086c1: e8 fa 0b 00 00 call 1092c0 <== 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) 1086c6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1086c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1086cb: 0f 85 76 01 00 00 jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 1086d1: 51 push %ecx <== NOT EXECUTED 1086d2: 51 push %ecx <== NOT EXECUTED 1086d3: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax <== NOT EXECUTED 1086d9: 50 push %eax <== NOT EXECUTED 1086da: 6a 00 push $0x0 <== NOT EXECUTED 1086dc: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1086e1: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1086e6: 6a 09 push $0x9 <== NOT EXECUTED 1086e8: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 1086ef: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED 1086f4: 50 push %eax <== NOT EXECUTED 1086f5: e8 c6 0b 00 00 call 1092c0 <== 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) 1086fa: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1086fd: 85 c0 test %eax,%eax <== NOT EXECUTED 1086ff: 0f 85 42 01 00 00 jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 108705: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) <== NOT EXECUTED 10870c: 74 09 je 108717 <== NOT EXECUTED 10870e: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 108715: 75 2a jne 108741 <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 108717: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10871a: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10871d: 50 push %eax <== NOT EXECUTED 10871e: 6a 00 push $0x0 <== NOT EXECUTED 108720: 6a 24 push $0x24 <== NOT EXECUTED 108722: 6a 00 push $0x0 <== NOT EXECUTED 108724: 0f be 05 48 a9 11 00 movsbl 0x11a948,%eax <== NOT EXECUTED 10872b: 0d 00 72 52 54 or $0x54527200,%eax <== NOT EXECUTED 108730: 50 push %eax <== NOT EXECUTED 108731: e8 de 07 00 00 call 108f14 <== NOT EXECUTED rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 108736: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108739: 85 c0 test %eax,%eax <== NOT EXECUTED 10873b: 0f 85 06 01 00 00 jne 108847 <== NOT EXECUTED } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 108741: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) <== NOT EXECUTED tty->termios.c_oflag = OPOST | ONLCR | XTABS; 108748: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) <== NOT EXECUTED tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 10874f: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) <== NOT EXECUTED tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 108756: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) <== NOT EXECUTED tty->termios.c_cc[VINTR] = '\003'; 10875d: c6 43 41 03 movb $0x3,0x41(%ebx) <== NOT EXECUTED tty->termios.c_cc[VQUIT] = '\034'; 108761: c6 43 42 1c movb $0x1c,0x42(%ebx) <== NOT EXECUTED tty->termios.c_cc[VERASE] = '\177'; 108765: c6 43 43 7f movb $0x7f,0x43(%ebx) <== NOT EXECUTED tty->termios.c_cc[VKILL] = '\025'; 108769: c6 43 44 15 movb $0x15,0x44(%ebx) <== NOT EXECUTED tty->termios.c_cc[VEOF] = '\004'; 10876d: c6 43 45 04 movb $0x4,0x45(%ebx) <== NOT EXECUTED tty->termios.c_cc[VEOL] = '\000'; 108771: c6 43 4c 00 movb $0x0,0x4c(%ebx) <== NOT EXECUTED tty->termios.c_cc[VEOL2] = '\000'; 108775: c6 43 51 00 movb $0x0,0x51(%ebx) <== NOT EXECUTED tty->termios.c_cc[VSTART] = '\021'; 108779: c6 43 49 11 movb $0x11,0x49(%ebx) <== NOT EXECUTED tty->termios.c_cc[VSTOP] = '\023'; 10877d: c6 43 4a 13 movb $0x13,0x4a(%ebx) <== NOT EXECUTED tty->termios.c_cc[VSUSP] = '\032'; 108781: c6 43 4b 1a movb $0x1a,0x4b(%ebx) <== NOT EXECUTED tty->termios.c_cc[VREPRINT] = '\022'; 108785: c6 43 4d 12 movb $0x12,0x4d(%ebx) <== NOT EXECUTED tty->termios.c_cc[VDISCARD] = '\017'; 108789: c6 43 4e 0f movb $0xf,0x4e(%ebx) <== NOT EXECUTED tty->termios.c_cc[VWERASE] = '\027'; 10878d: c6 43 4f 17 movb $0x17,0x4f(%ebx) <== NOT EXECUTED tty->termios.c_cc[VLNEXT] = '\026'; 108791: c6 43 50 16 movb $0x16,0x50(%ebx) <== NOT EXECUTED /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 108795: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) <== NOT EXECUTED 10879c: 00 00 00 <== NOT EXECUTED /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 10879f: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 1087a2: d1 e8 shr %eax <== NOT EXECUTED 1087a4: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED tty->highwater = tty->rawInBuf.Size * 3/4; 1087aa: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 1087ad: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 1087b0: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 1087b3: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) <== NOT EXECUTED /* * Bump name characer */ if (c++ == 'z') 1087b9: 8a 15 48 a9 11 00 mov 0x11a948,%dl <== NOT EXECUTED 1087bf: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1087c2: a2 48 a9 11 00 mov %al,0x11a948 <== NOT EXECUTED 1087c7: 80 fa 7a cmp $0x7a,%dl <== NOT EXECUTED 1087ca: 75 07 jne 1087d3 <== NOT EXECUTED c = 'a'; 1087cc: c6 05 48 a9 11 00 61 movb $0x61,0x11a948 <== NOT EXECUTED } args->iop->data1 = tty; 1087d3: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1087d6: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1087d8: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 1087db: 89 48 28 mov %ecx,0x28(%eax) <== NOT EXECUTED if (!tty->refcount++) { 1087de: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 1087e1: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1087e4: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED 1087e7: 85 d2 test %edx,%edx <== NOT EXECUTED 1087e9: 75 65 jne 108850 <== NOT EXECUTED if (tty->device.firstOpen) 1087eb: 8b 81 98 00 00 00 mov 0x98(%ecx),%eax <== NOT EXECUTED 1087f1: 85 c0 test %eax,%eax <== NOT EXECUTED 1087f3: 74 0f je 108804 <== NOT EXECUTED (*tty->device.firstOpen)(major, minor, arg); 1087f5: 52 push %edx <== NOT EXECUTED 1087f6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1087f9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1087fc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1087ff: ff d0 call *%eax <== NOT EXECUTED 108801: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108804: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 108807: 83 be b4 00 00 00 02 cmpl $0x2,0xb4(%esi) <== NOT EXECUTED 10880e: 75 40 jne 108850 <== NOT EXECUTED sc = rtems_task_start(tty->rxTaskId, 108810: 50 push %eax <== NOT EXECUTED 108811: 56 push %esi <== NOT EXECUTED 108812: 68 f2 88 10 00 push $0x1088f2 <== NOT EXECUTED 108817: ff b6 c4 00 00 00 pushl 0xc4(%esi) <== NOT EXECUTED 10881d: e8 0e 0d 00 00 call 109530 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 108822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108825: 85 c0 test %eax,%eax <== NOT EXECUTED 108827: 75 1e jne 108847 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start(tty->txTaskId, 108829: 50 push %eax <== NOT EXECUTED 10882a: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10882d: 68 8f 88 10 00 push $0x10888f <== NOT EXECUTED 108832: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108835: ff b0 c8 00 00 00 pushl 0xc8(%eax) <== NOT EXECUTED 10883b: e8 f0 0c 00 00 call 109530 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 108840: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108843: 85 c0 test %eax,%eax <== NOT EXECUTED 108845: 74 09 je 108850 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 108847: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10884a: 50 push %eax <== NOT EXECUTED 10884b: e8 10 0f 00 00 call 109760 <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 108850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108853: ff 35 3c c9 11 00 pushl 0x11c93c <== NOT EXECUTED 108859: e8 d2 09 00 00 call 109230 <== NOT EXECUTED 10885e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108861: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 108864: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108867: 5b pop %ebx <== NOT EXECUTED 108868: 5e pop %esi <== NOT EXECUTED 108869: 5f pop %edi <== NOT EXECUTED 10886a: c9 leave <== NOT EXECUTED 10886b: c3 ret <== NOT EXECUTED static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 10886c: 50 push %eax <== NOT EXECUTED 10886d: 50 push %eax <== NOT EXECUTED 10886e: 68 e8 00 00 00 push $0xe8 <== NOT EXECUTED 108873: 6a 01 push $0x1 <== NOT EXECUTED 108875: e8 6a 43 00 00 call 10cbe4 <== NOT EXECUTED 10887a: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10887d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (tty == NULL) { 10887f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108882: 85 c0 test %eax,%eax <== NOT EXECUTED 108884: 0f 85 50 fc ff ff jne 1084da <== NOT EXECUTED 10888a: e9 43 fc ff ff jmp 1084d2 <== NOT EXECUTED 00107667 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 107667: 55 push %ebp <== NOT EXECUTED 107668: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10766a: 57 push %edi <== NOT EXECUTED 10766b: 56 push %esi <== NOT EXECUTED 10766c: 53 push %ebx <== NOT EXECUTED 10766d: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 107670: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107673: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 107676: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 107679: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED const unsigned char *buf = _buf; 10767c: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 10767f: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) <== NOT EXECUTED 107686: 75 1b jne 1076a3 <== NOT EXECUTED (*tty->device.write)(tty->minor, (void *)buf, len); 107688: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 10768b: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10768e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 107691: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 107694: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 10769a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10769d: 5b pop %ebx <== NOT EXECUTED 10769e: 5e pop %esi <== NOT EXECUTED 10769f: 5f pop %edi <== NOT EXECUTED 1076a0: 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); 1076a1: ff e1 jmp *%ecx <== NOT EXECUTED return; } newHead = tty->rawOutBuf.Head; 1076a3: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 1076a9: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1076ac: e9 b9 00 00 00 jmp 10776a <== NOT EXECUTED * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 1076b1: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 1076b4: 46 inc %esi <== NOT EXECUTED 1076b5: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx <== NOT EXECUTED 1076bb: 89 f0 mov %esi,%eax <== NOT EXECUTED 1076bd: 31 d2 xor %edx,%edx <== NOT EXECUTED 1076bf: f7 f1 div %ecx <== NOT EXECUTED 1076c1: 89 d6 mov %edx,%esi <== NOT EXECUTED 1076c3: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED rtems_interrupt_disable (level); 1076c6: 9c pushf <== NOT EXECUTED 1076c7: fa cli <== NOT EXECUTED 1076c8: 5f pop %edi <== NOT EXECUTED 1076c9: eb 2f jmp 1076fa <== NOT EXECUTED while (newHead == tty->rawOutBuf.Tail) { tty->rawOutBufState = rob_wait; 1076cb: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) <== NOT EXECUTED 1076d2: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable (level); 1076d5: 57 push %edi <== NOT EXECUTED 1076d6: 9d popf <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 1076d7: 51 push %ecx <== NOT EXECUTED 1076d8: 6a 00 push $0x0 <== NOT EXECUTED 1076da: 6a 00 push $0x0 <== NOT EXECUTED 1076dc: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 1076e2: e8 61 1a 00 00 call 109148 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1076e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1076ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1076ec: 74 09 je 1076f7 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1076ee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1076f1: 50 push %eax <== NOT EXECUTED 1076f2: e8 69 20 00 00 call 109760 <== NOT EXECUTED rtems_interrupt_disable (level); 1076f7: 9c pushf <== NOT EXECUTED 1076f8: fa cli <== NOT EXECUTED 1076f9: 5f pop %edi <== NOT EXECUTED * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; rtems_interrupt_disable (level); while (newHead == tty->rawOutBuf.Tail) { 1076fa: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 107700: 39 c6 cmp %eax,%esi <== NOT EXECUTED 107702: 74 c7 je 1076cb <== NOT EXECUTED RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 107704: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx <== NOT EXECUTED 10770a: 8b 53 7c mov 0x7c(%ebx),%edx <== NOT EXECUTED 10770d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 107710: 8a 00 mov (%eax),%al <== NOT EXECUTED 107712: 88 04 0a mov %al,(%edx,%ecx,1) <== NOT EXECUTED tty->rawOutBuf.Head = newHead; 107715: 89 b3 80 00 00 00 mov %esi,0x80(%ebx) <== NOT EXECUTED if (tty->rawOutBufState == rob_idle) { 10771b: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 107722: 75 3e jne 107762 <== NOT EXECUTED /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 107724: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10772a: a8 10 test $0x10,%al <== NOT EXECUTED 10772c: 75 1b jne 107749 <== NOT EXECUTED (*tty->device.write)(tty->minor, 10772e: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 107734: 52 push %edx <== NOT EXECUTED 107735: 6a 01 push $0x1 <== NOT EXECUTED 107737: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10773a: 50 push %eax <== NOT EXECUTED 10773b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10773e: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 107744: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107747: eb 0f jmp 107758 <== NOT EXECUTED (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 107749: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10774f: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 107752: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 107758: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 10775f: 00 00 00 <== NOT EXECUTED RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 107762: ff 45 ec incl -0x14(%ebp) <== NOT EXECUTED /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; } tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); 107765: 57 push %edi <== NOT EXECUTED 107766: 9d popf <== NOT EXECUTED len--; 107767: ff 4d e8 decl -0x18(%ebp) <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 10776a: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) <== NOT EXECUTED 10776e: 0f 85 3d ff ff ff jne 1076b1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 107774: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107777: 5b pop %ebx <== NOT EXECUTED 107778: 5e pop %esi <== NOT EXECUTED 107779: 5f pop %edi <== NOT EXECUTED 10777a: c9 leave <== NOT EXECUTED 10777b: c3 ret <== NOT EXECUTED 00107cb3 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 107cb3: 55 push %ebp <== NOT EXECUTED 107cb4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107cb6: 57 push %edi <== NOT EXECUTED 107cb7: 56 push %esi <== NOT EXECUTED 107cb8: 53 push %ebx <== NOT EXECUTED 107cb9: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107cbc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107cbf: 8b 02 mov (%edx),%eax <== NOT EXECUTED 107cc1: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED uint32_t count = args->count; 107cc4: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED 107cc7: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 107cca: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 107ccd: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107cd0: 6a 00 push $0x0 <== NOT EXECUTED 107cd2: 6a 00 push $0x0 <== NOT EXECUTED 107cd4: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 107cd7: e8 6c 14 00 00 call 109148 <== NOT EXECUTED 107cdc: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 107cdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107ce2: 85 c0 test %eax,%eax <== NOT EXECUTED 107ce4: 0f 85 c8 02 00 00 jne 107fb2 <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 107cea: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 107cf0: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107cf3: 8b 80 bc c6 11 00 mov 0x11c6bc(%eax),%eax <== NOT EXECUTED 107cf9: 85 c0 test %eax,%eax <== NOT EXECUTED 107cfb: 74 1b je 107d18 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 107cfd: 52 push %edx <== NOT EXECUTED 107cfe: 52 push %edx <== NOT EXECUTED 107cff: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107d02: 56 push %esi <== NOT EXECUTED 107d03: ff d0 call *%eax <== NOT EXECUTED 107d05: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 107d08: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 107d0f: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 107d12: 58 pop %eax <== NOT EXECUTED 107d13: e9 8f 02 00 00 jmp 107fa7 <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { 107d18: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 107d1b: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 107d1e: 0f 85 5c 02 00 00 jne 107f80 <== NOT EXECUTED tty->cindex = tty->ccount = 0; 107d24: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED 107d2b: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED tty->read_start_column = tty->column; 107d32: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED 107d35: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED if (tty->device.pollRead != NULL 107d38: 83 be a0 00 00 00 00 cmpl $0x0,0xa0(%esi) <== NOT EXECUTED 107d3f: 0f 84 f8 00 00 00 je 107e3d <== NOT EXECUTED 107d45: 83 be b4 00 00 00 00 cmpl $0x0,0xb4(%esi) <== NOT EXECUTED 107d4c: 0f 85 eb 00 00 00 jne 107e3d <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 107d52: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 107d56: 74 35 je 107d8d <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 107d58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d5b: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107d5e: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED if (n < 0) { 107d64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d67: 85 c0 test %eax,%eax <== NOT EXECUTED 107d69: 79 0f jns 107d7a <== NOT EXECUTED rtems_task_wake_after (1); 107d6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d6e: 6a 01 push $0x1 <== NOT EXECUTED 107d70: e8 1f 18 00 00 call 109594 <== NOT EXECUTED 107d75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d78: eb de jmp 107d58 <== NOT EXECUTED } else { if (siproc (n, tty)) 107d7a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107d7d: 89 f2 mov %esi,%edx <== NOT EXECUTED 107d7f: e8 db fd ff ff call 107b5f <== NOT EXECUTED 107d84: 85 c0 test %eax,%eax <== NOT EXECUTED 107d86: 74 d0 je 107d58 <== NOT EXECUTED 107d88: e9 f3 01 00 00 jmp 107f80 <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 107d8d: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 107d91: 75 16 jne 107da9 <== NOT EXECUTED 107d93: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107d97: 74 10 je 107da9 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 107d99: 50 push %eax <== NOT EXECUTED 107d9a: 50 push %eax <== NOT EXECUTED 107d9b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 107d9e: 50 push %eax <== NOT EXECUTED 107d9f: 6a 02 push $0x2 <== NOT EXECUTED 107da1: e8 b2 0b 00 00 call 108958 <== NOT EXECUTED 107da6: 83 c4 10 add $0x10,%esp <== 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); 107da9: 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); 107dac: 8d 5d ec lea -0x14(%ebp),%ebx <== 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); 107daf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107db2: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107db5: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED if (n < 0) { 107dbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107dbe: 85 c0 test %eax,%eax <== NOT EXECUTED 107dc0: 79 46 jns 107e08 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 107dc2: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 107dc6: 74 0e je 107dd6 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 107dc8: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107dcc: 74 2e je 107dfc <== NOT EXECUTED 107dce: 83 7e 20 00 cmpl $0x0,0x20(%esi) <== NOT EXECUTED 107dd2: 74 28 je 107dfc <== NOT EXECUTED 107dd4: eb 0a jmp 107de0 <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 107dd6: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107dda: 0f 84 a0 01 00 00 je 107f80 <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 107de0: 50 push %eax <== NOT EXECUTED 107de1: 50 push %eax <== NOT EXECUTED 107de2: 53 push %ebx <== NOT EXECUTED 107de3: 6a 02 push $0x2 <== NOT EXECUTED 107de5: e8 6e 0b 00 00 call 108958 <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 107dea: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 107ded: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 107df0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107df3: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED 107df6: 0f 87 84 01 00 00 ja 107f80 <== NOT EXECUTED break; } } rtems_task_wake_after (1); 107dfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107dff: 6a 01 push $0x1 <== NOT EXECUTED 107e01: e8 8e 17 00 00 call 109594 <== NOT EXECUTED 107e06: eb 2d jmp 107e35 <== NOT EXECUTED } else { siproc (n, tty); 107e08: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107e0b: 89 f2 mov %esi,%edx <== NOT EXECUTED 107e0d: e8 4d fd ff ff call 107b5f <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 107e12: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED 107e15: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 107e18: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107e1b: 0f 8d 5f 01 00 00 jge 107f80 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 107e21: 84 d2 test %dl,%dl <== NOT EXECUTED 107e23: 74 8a je 107daf <== NOT EXECUTED 107e25: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107e29: 74 84 je 107daf <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 107e2b: 50 push %eax <== NOT EXECUTED 107e2c: 50 push %eax <== NOT EXECUTED 107e2d: 57 push %edi <== NOT EXECUTED 107e2e: 6a 02 push $0x2 <== NOT EXECUTED 107e30: e8 23 0b 00 00 call 108958 <== NOT EXECUTED 107e35: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107e38: e9 72 ff ff ff jmp 107daf <== 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; 107e3d: 8b 7e 74 mov 0x74(%esi),%edi <== 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, 107e40: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED 107e43: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 107e46: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 107e4b: e9 11 01 00 00 jmp 107f61 <== NOT EXECUTED while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 107e50: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 107e53: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 107e56: 40 inc %eax <== NOT EXECUTED 107e57: 89 d1 mov %edx,%ecx <== NOT EXECUTED 107e59: 31 d2 xor %edx,%edx <== NOT EXECUTED 107e5b: f7 f1 div %ecx <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 107e5d: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 107e60: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED tty->rawInBuf.Head = newHead; 107e64: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 107e67: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED 107e6a: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 107e6d: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 107e70: 01 d8 add %ebx,%eax <== NOT EXECUTED 107e72: 29 d0 sub %edx,%eax <== NOT EXECUTED 107e74: 31 d2 xor %edx,%edx <== NOT EXECUTED 107e76: f7 f1 div %ecx <== NOT EXECUTED 107e78: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED 107e7e: 73 74 jae 107ef4 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 107e80: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107e86: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 107e89: 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)) 107e8f: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107e95: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED 107e9a: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED 107e9f: 75 24 jne 107ec5 <== NOT EXECUTED 107ea1: 83 be 94 00 00 00 00 cmpl $0x0,0x94(%esi) <== NOT EXECUTED 107ea8: 74 0a je 107eb4 <== NOT EXECUTED 107eaa: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107eb0: a8 20 test $0x20,%al <== NOT EXECUTED 107eb2: 74 11 je 107ec5 <== 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, 107eb4: 50 push %eax <== NOT EXECUTED 107eb5: 6a 01 push $0x1 <== NOT EXECUTED 107eb7: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 107eba: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107ebd: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 107ec3: eb 2c jmp 107ef1 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 107ec5: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107ecb: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 107ece: 74 24 je 107ef4 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 107ed0: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107ed6: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 107ed9: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 107edf: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED 107ee5: 85 c0 test %eax,%eax <== NOT EXECUTED 107ee7: 74 0b je 107ef4 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 107ee9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107eec: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107eef: ff d0 call *%eax <== NOT EXECUTED 107ef1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 107ef4: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 107ef8: 74 12 je 107f0c <== NOT EXECUTED if (siproc (c, tty)) 107efa: 89 fa mov %edi,%edx <== NOT EXECUTED 107efc: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 107eff: 89 f2 mov %esi,%edx <== NOT EXECUTED 107f01: e8 59 fc ff ff call 107b5f <== NOT EXECUTED 107f06: 85 c0 test %eax,%eax <== NOT EXECUTED 107f08: 75 17 jne 107f21 <== NOT EXECUTED 107f0a: eb 1c jmp 107f28 <== NOT EXECUTED wait = 0; } else { siproc (c, tty); 107f0c: 89 f9 mov %edi,%ecx <== NOT EXECUTED 107f0e: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 107f11: 89 f2 mov %esi,%edx <== NOT EXECUTED 107f13: e8 47 fc ff ff call 107b5f <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 107f18: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED 107f1c: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107f1f: 7c 07 jl 107f28 <== NOT EXECUTED 107f21: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 107f28: 8b 4e 70 mov 0x70(%esi),%ecx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 107f2b: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 107f2e: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 107f31: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107f33: 74 0f je 107f44 <== NOT EXECUTED 107f35: a1 3c a9 11 00 mov 0x11a93c,%eax <== NOT EXECUTED 107f3a: 48 dec %eax <== NOT EXECUTED 107f3b: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107f3e: 0f 8c 0c ff ff ff jl 107e50 <== NOT EXECUTED 107f44: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED 107f47: 89 cf mov %ecx,%edi <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 107f49: 85 db test %ebx,%ebx <== NOT EXECUTED 107f4b: 74 33 je 107f80 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 107f4d: 50 push %eax <== NOT EXECUTED 107f4e: 51 push %ecx <== NOT EXECUTED 107f4f: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED 107f52: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 107f55: e8 ee 11 00 00 call 109148 <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 107f5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107f5d: 85 c0 test %eax,%eax <== NOT EXECUTED 107f5f: 75 1f jne 107f80 <== NOT EXECUTED { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; rtems_status_code sc; int wait = (int)1; while ( wait ) { 107f61: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 107f64: 89 f9 mov %edi,%ecx <== NOT EXECUTED 107f66: eb c3 jmp 107f2b <== NOT EXECUTED sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 107f68: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 107f6b: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 107f6e: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107f71: 88 01 mov %al,(%ecx) <== NOT EXECUTED 107f73: 41 inc %ecx <== NOT EXECUTED 107f74: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED 107f77: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 107f7a: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED count--; 107f7d: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 107f80: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) <== NOT EXECUTED 107f84: 74 08 je 107f8e <== NOT EXECUTED 107f86: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 107f89: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED 107f8c: 7c da jl 107f68 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 107f8e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107f91: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107f94: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 107f97: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 107f9a: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 107fa1: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 107fa4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107fa7: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 107faa: e8 81 12 00 00 call 109230 <== NOT EXECUTED 107faf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 107fb2: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 107fb5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107fb8: 5b pop %ebx <== NOT EXECUTED 107fb9: 5e pop %esi <== NOT EXECUTED 107fba: 5f pop %edi <== NOT EXECUTED 107fbb: c9 leave <== NOT EXECUTED 107fbc: c3 ret <== NOT EXECUTED 001071ae : * 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) { 1071ae: 55 push %ebp <== NOT EXECUTED 1071af: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071b1: 57 push %edi <== NOT EXECUTED 1071b2: 56 push %esi <== NOT EXECUTED 1071b3: 53 push %ebx <== NOT EXECUTED 1071b4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071b7: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 1071ba: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1071c0: 25 03 04 00 00 and $0x403,%eax <== NOT EXECUTED 1071c5: 3d 01 04 00 00 cmp $0x401,%eax <== NOT EXECUTED 1071ca: 75 2c jne 1071f8 <== NOT EXECUTED == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, 1071cc: 57 push %edi <== NOT EXECUTED 1071cd: 6a 01 push $0x1 <== NOT EXECUTED 1071cf: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED 1071d2: 50 push %eax <== NOT EXECUTED 1071d3: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 1071d6: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 1071dc: 9c pushf <== NOT EXECUTED 1071dd: fa cli <== NOT EXECUTED 1071de: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 1071df: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 1071e5: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1071eb: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1071ee: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED rtems_interrupt_enable(level); 1071f4: 52 push %edx <== NOT EXECUTED 1071f5: 9d popf <== NOT EXECUTED 1071f6: eb 38 jmp 107230 <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 1071f8: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1071fe: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 107201: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 107204: 75 37 jne 10723d <== NOT EXECUTED * FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor, 107206: 53 push %ebx <== NOT EXECUTED 107207: 6a 01 push $0x1 <== NOT EXECUTED 107209: 8d 46 49 lea 0x49(%esi),%eax <== NOT EXECUTED 10720c: 50 push %eax <== NOT EXECUTED 10720d: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107210: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 107216: 9c pushf <== NOT EXECUTED 107217: fa cli <== NOT EXECUTED 107218: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107219: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 10721f: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107225: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 107228: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED rtems_interrupt_enable(level); 10722e: 52 push %edx <== NOT EXECUTED 10722f: 9d popf <== NOT EXECUTED 107230: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 107235: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107238: e9 34 01 00 00 jmp 107371 <== NOT EXECUTED nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 10723d: 8b 96 80 00 00 00 mov 0x80(%esi),%edx <== NOT EXECUTED 107243: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED 107249: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10724b: 75 21 jne 10726e <== NOT EXECUTED /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 10724d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10724f: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) <== NOT EXECUTED 107256: 0f 85 15 01 00 00 jne 107371 <== NOT EXECUTED /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10725c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10725f: ff b6 8c 00 00 00 pushl 0x8c(%esi) <== NOT EXECUTED 107265: e8 c6 1f 00 00 call 109230 <== NOT EXECUTED 10726a: 31 db xor %ebx,%ebx <== NOT EXECUTED 10726c: eb c7 jmp 107235 <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 10726e: 9c pushf <== NOT EXECUTED 10726f: fa cli <== NOT EXECUTED 107270: 58 pop %eax <== NOT EXECUTED len = tty->t_dqlen; 107271: 8b 8e 90 00 00 00 mov 0x90(%esi),%ecx <== NOT EXECUTED tty->t_dqlen = 0; 107277: c7 86 90 00 00 00 00 movl $0x0,0x90(%esi) <== NOT EXECUTED 10727e: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable(level); 107281: 50 push %eax <== NOT EXECUTED 107282: 9d popf <== NOT EXECUTED newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 107283: 8b 96 84 00 00 00 mov 0x84(%esi),%edx <== NOT EXECUTED 107289: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx <== NOT EXECUTED 10728f: 01 d1 add %edx,%ecx <== NOT EXECUTED 107291: 89 c8 mov %ecx,%eax <== NOT EXECUTED 107293: 31 d2 xor %edx,%edx <== NOT EXECUTED 107295: f7 f3 div %ebx <== NOT EXECUTED 107297: 89 d7 mov %edx,%edi <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; 107299: 89 96 84 00 00 00 mov %edx,0x84(%esi) <== NOT EXECUTED if (tty->rawOutBufState == rob_wait) { 10729f: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) <== NOT EXECUTED 1072a6: 75 11 jne 1072b9 <== NOT EXECUTED /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 1072a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1072ab: ff b6 8c 00 00 00 pushl 0x8c(%esi) <== NOT EXECUTED 1072b1: e8 7a 1f 00 00 call 109230 <== NOT EXECUTED 1072b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { 1072b9: 8b 86 80 00 00 00 mov 0x80(%esi),%eax <== NOT EXECUTED 1072bf: 39 c7 cmp %eax,%edi <== NOT EXECUTED 1072c1: 75 2c jne 1072ef <== NOT EXECUTED /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 1072c3: c7 86 94 00 00 00 00 movl $0x0,0x94(%esi) <== NOT EXECUTED 1072ca: 00 00 00 <== NOT EXECUTED nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 1072cd: 8b 96 d4 00 00 00 mov 0xd4(%esi),%edx <== NOT EXECUTED 1072d3: 31 db xor %ebx,%ebx <== NOT EXECUTED 1072d5: 85 d2 test %edx,%edx <== NOT EXECUTED 1072d7: 0f 84 8e 00 00 00 je 10736b <== NOT EXECUTED (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 1072dd: 51 push %ecx <== NOT EXECUTED 1072de: 51 push %ecx <== NOT EXECUTED 1072df: ff b6 d8 00 00 00 pushl 0xd8(%esi) <== NOT EXECUTED 1072e5: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED 1072e8: 50 push %eax <== NOT EXECUTED 1072e9: ff d2 call *%edx <== NOT EXECUTED 1072eb: 31 db xor %ebx,%ebx <== NOT EXECUTED 1072ed: eb 79 jmp 107368 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 1072ef: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1072f5: 25 10 02 00 00 and $0x210,%eax <== NOT EXECUTED 1072fa: 3d 10 02 00 00 cmp $0x210,%eax <== NOT EXECUTED 1072ff: 75 22 jne 107323 <== NOT EXECUTED == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 107301: 9c pushf <== NOT EXECUTED 107302: fa cli <== NOT EXECUTED 107303: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 107304: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 10730a: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10730d: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 107313: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) <== NOT EXECUTED 10731a: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable(level); 10731d: 52 push %edx <== NOT EXECUTED 10731e: 9d popf <== NOT EXECUTED 10731f: 31 db xor %ebx,%ebx <== NOT EXECUTED 107321: eb 48 jmp 10736b <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 107323: 8b 86 80 00 00 00 mov 0x80(%esi),%eax <== NOT EXECUTED 107329: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10732b: 76 08 jbe 107335 <== NOT EXECUTED nToSend = tty->rawOutBuf.Size - newTail; 10732d: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx <== NOT EXECUTED 107333: eb 06 jmp 10733b <== NOT EXECUTED else nToSend = tty->rawOutBuf.Head - newTail; 107335: 8b 9e 80 00 00 00 mov 0x80(%esi),%ebx <== NOT EXECUTED 10733b: 29 fb sub %edi,%ebx <== NOT EXECUTED /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 10733d: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107343: f6 c4 06 test $0x6,%ah <== NOT EXECUTED 107346: 74 05 je 10734d <== NOT EXECUTED 107348: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 10734d: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) <== NOT EXECUTED 107354: 00 00 00 <== NOT EXECUTED (*tty->device.write)(tty->minor, 107357: 50 push %eax <== NOT EXECUTED 107358: 53 push %ebx <== NOT EXECUTED 107359: 8b 46 7c mov 0x7c(%esi),%eax <== NOT EXECUTED 10735c: 01 f8 add %edi,%eax <== NOT EXECUTED 10735e: 50 push %eax <== NOT EXECUTED 10735f: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107362: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 107368: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 10736b: 89 be 84 00 00 00 mov %edi,0x84(%esi) <== NOT EXECUTED } return nToSend; } 107371: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107373: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107376: 5b pop %ebx <== NOT EXECUTED 107377: 5e pop %esi <== NOT EXECUTED 107378: 5f pop %edi <== NOT EXECUTED 107379: c9 leave <== NOT EXECUTED 10737a: c3 ret <== NOT EXECUTED 001088f2 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 1088f2: 55 push %ebp <== NOT EXECUTED 1088f3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1088f5: 57 push %edi <== NOT EXECUTED 1088f6: 56 push %esi <== NOT EXECUTED 1088f7: 53 push %ebx <== NOT EXECUTED 1088f8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1088fb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 1088fe: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( 108901: 8d 75 f3 lea -0xd(%ebp),%esi <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 108904: 57 push %edi <== NOT EXECUTED 108905: 6a 00 push $0x0 <== NOT EXECUTED 108907: 6a 02 push $0x2 <== NOT EXECUTED 108909: 6a 03 push $0x3 <== NOT EXECUTED 10890b: e8 38 02 00 00 call 108b48 <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 108910: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108913: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED 108917: 74 16 je 10892f <== NOT EXECUTED tty->rxTaskId = 0; 108919: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 108920: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 108923: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108926: 6a 00 push $0x0 <== NOT EXECUTED 108928: e8 c3 0a 00 00 call 1093f0 <== NOT EXECUTED 10892d: eb 21 jmp 108950 <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 10892f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108932: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108935: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (c != EOF) { 10893b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10893e: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 108941: 74 c1 je 108904 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 108943: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 108946: 50 push %eax <== NOT EXECUTED 108947: 6a 01 push $0x1 <== NOT EXECUTED 108949: 56 push %esi <== NOT EXECUTED 10894a: 53 push %ebx <== NOT EXECUTED 10894b: e8 8f ea ff ff call 1073df <== NOT EXECUTED 108950: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108953: eb af jmp 108904 <== NOT EXECUTED 00107193 : * 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) { 107193: 55 push %ebp <== NOT EXECUTED 107194: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107196: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT); 107199: 6a 02 push $0x2 <== NOT EXECUTED 10719b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10719e: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED 1071a4: e8 0f 1b 00 00 call 108cb8 <== NOT EXECUTED 1071a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1071ac: c9 leave <== NOT EXECUTED 1071ad: c3 ret <== NOT EXECUTED 0010888f : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 10888f: 55 push %ebp <== NOT EXECUTED 108890: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108892: 56 push %esi <== NOT EXECUTED 108893: 53 push %ebx <== NOT EXECUTED 108894: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108897: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 10889a: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 10889d: 56 push %esi <== NOT EXECUTED 10889e: 6a 00 push $0x0 <== NOT EXECUTED 1088a0: 6a 02 push $0x2 <== NOT EXECUTED 1088a2: 6a 03 push $0x3 <== NOT EXECUTED 1088a4: e8 9f 02 00 00 call 108b48 <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 1088a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088ac: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED 1088b0: 74 16 je 1088c8 <== NOT EXECUTED tty->txTaskId = 0; 1088b2: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 1088b9: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 1088bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1088bf: 6a 00 push $0x0 <== NOT EXECUTED 1088c1: e8 2a 0b 00 00 call 1093f0 <== NOT EXECUTED 1088c6: eb 25 jmp 1088ed <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1088c8: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1088ce: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1088d1: 8b 80 c8 c6 11 00 mov 0x11c6c8(%eax),%eax <== NOT EXECUTED 1088d7: 85 c0 test %eax,%eax <== NOT EXECUTED 1088d9: 74 09 je 1088e4 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 1088db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1088de: 53 push %ebx <== NOT EXECUTED 1088df: ff d0 call *%eax <== NOT EXECUTED 1088e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 1088e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1088e7: 53 push %ebx <== NOT EXECUTED 1088e8: e8 c1 e8 ff ff call 1071ae <== NOT EXECUTED 1088ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088f0: eb ab jmp 10889d <== NOT EXECUTED 00107bad : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 107bad: 55 push %ebp <== NOT EXECUTED 107bae: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107bb0: 57 push %edi <== NOT EXECUTED 107bb1: 56 push %esi <== NOT EXECUTED 107bb2: 53 push %ebx <== NOT EXECUTED 107bb3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107bb6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107bb9: 8b 02 mov (%edx),%eax <== NOT EXECUTED 107bbb: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107bbe: 6a 00 push $0x0 <== NOT EXECUTED 107bc0: 6a 00 push $0x0 <== NOT EXECUTED 107bc2: ff 77 18 pushl 0x18(%edi) <== NOT EXECUTED 107bc5: e8 7e 15 00 00 call 109148 <== NOT EXECUTED 107bca: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 107bcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107bd0: 85 c0 test %eax,%eax <== NOT EXECUTED 107bd2: 75 77 jne 107c4b <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 107bd4: 8b 87 cc 00 00 00 mov 0xcc(%edi),%eax <== NOT EXECUTED 107bda: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107bdd: 8b 80 c0 c6 11 00 mov 0x11c6c0(%eax),%eax <== NOT EXECUTED 107be3: 85 c0 test %eax,%eax <== NOT EXECUTED 107be5: 74 0e je 107bf5 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 107be7: 52 push %edx <== NOT EXECUTED 107be8: 52 push %edx <== NOT EXECUTED 107be9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107bec: 57 push %edi <== NOT EXECUTED 107bed: ff d0 call *%eax <== NOT EXECUTED 107bef: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED rtems_semaphore_release (tty->osem); 107bf2: 5e pop %esi <== NOT EXECUTED 107bf3: eb 4b jmp 107c40 <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { 107bf5: f6 47 34 01 testb $0x1,0x34(%edi) <== NOT EXECUTED 107bf9: 74 26 je 107c21 <== NOT EXECUTED uint32_t count = args->count; 107bfb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107bfe: 8b 70 0c mov 0xc(%eax),%esi <== NOT EXECUTED char *buffer = args->buffer; 107c01: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 107c04: eb 0c jmp 107c12 <== NOT EXECUTED while (count--) oproc (*buffer++, tty); 107c06: 0f b6 03 movzbl (%ebx),%eax <== NOT EXECUTED 107c09: 43 inc %ebx <== NOT EXECUTED 107c0a: 89 fa mov %edi,%edx <== NOT EXECUTED 107c0c: e8 6b fb ff ff call 10777c <== NOT EXECUTED 107c11: 4e dec %esi <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 107c12: 85 f6 test %esi,%esi <== NOT EXECUTED 107c14: 75 f0 jne 107c06 <== NOT EXECUTED oproc (*buffer++, tty); args->bytes_moved = args->count; 107c16: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107c19: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107c1c: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 107c1f: eb 1c jmp 107c3d <== NOT EXECUTED } else { rtems_termios_puts (args->buffer, args->count, tty); 107c21: 53 push %ebx <== NOT EXECUTED 107c22: 57 push %edi <== NOT EXECUTED 107c23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107c26: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107c29: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107c2c: e8 36 fa ff ff call 107667 <== NOT EXECUTED args->bytes_moved = args->count; 107c31: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107c34: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107c37: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 107c3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 107c3d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c40: ff 77 18 pushl 0x18(%edi) <== NOT EXECUTED 107c43: e8 e8 15 00 00 call 109230 <== NOT EXECUTED 107c48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 107c4b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 107c4e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107c51: 5b pop %ebx <== NOT EXECUTED 107c52: 5e pop %esi <== NOT EXECUTED 107c53: 5f pop %edi <== NOT EXECUTED 107c54: c9 leave <== NOT EXECUTED 107c55: c3 ret <== NOT EXECUTED 00112aac : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 112aac: 55 push %ebp <== NOT EXECUTED 112aad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112aaf: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112ab2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 112ab5: 50 push %eax <== NOT EXECUTED 112ab6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112ab9: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112abe: e8 69 24 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ac3: 89 c2 mov %eax,%edx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ac5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ac8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112acd: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 112ad1: 75 1c jne 112aef <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 112ad3: 83 7a 38 04 cmpl $0x4,0x38(%edx) <== NOT EXECUTED 112ad7: 74 0f je 112ae8 <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 112ad9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112adc: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 112adf: 50 push %eax <== NOT EXECUTED 112ae0: e8 3b 3e 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED 112ae5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 112ae8: e8 ff 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112aed: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112aef: c9 leave <== NOT EXECUTED 112af0: c3 ret <== NOT EXECUTED 00112af4 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 112af4: 55 push %ebp <== NOT EXECUTED 112af5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112af7: 57 push %edi <== NOT EXECUTED 112af8: 56 push %esi <== NOT EXECUTED 112af9: 53 push %ebx <== NOT EXECUTED 112afa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112afd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 112b00: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 112b03: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 112b08: 85 f6 test %esi,%esi <== NOT EXECUTED 112b0a: 74 73 je 112b7f <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 112b0c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112b11: 85 ff test %edi,%edi <== NOT EXECUTED 112b13: 74 6a je 112b7f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112b15: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 112b1a: 40 inc %eax <== NOT EXECUTED 112b1b: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 112b20: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112b23: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112b28: e8 7f 1f 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 112b2d: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 112b2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b32: 85 c0 test %eax,%eax <== NOT EXECUTED 112b34: 75 0c jne 112b42 <== NOT EXECUTED _Thread_Enable_dispatch(); 112b36: e8 b1 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112b3b: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 112b40: eb 3d jmp 112b7f <== NOT EXECUTED return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 112b42: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112b49: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112b50: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112b57: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED * the heap 112b5e: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 112b65: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 112b68: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 112b6b: a1 f0 2a 13 00 mov 0x132af0,%eax <== NOT EXECUTED 112b70: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112b73: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 112b76: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 112b78: e8 6f 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112b7d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 112b7f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b82: 5b pop %ebx <== NOT EXECUTED 112b83: 5e pop %esi <== NOT EXECUTED 112b84: 5f pop %edi <== NOT EXECUTED 112b85: c9 leave <== NOT EXECUTED 112b86: c3 ret <== NOT EXECUTED 00112b88 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 112b88: 55 push %ebp <== NOT EXECUTED 112b89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112b8b: 53 push %ebx <== NOT EXECUTED 112b8c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112b8f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112b92: 50 push %eax <== NOT EXECUTED 112b93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112b96: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112b9b: e8 8c 23 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ba0: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ba2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ba5: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112baa: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112bae: 75 2f jne 112bdf <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 112bb0: 51 push %ecx <== NOT EXECUTED 112bb1: 51 push %ecx <== NOT EXECUTED 112bb2: 53 push %ebx <== NOT EXECUTED 112bb3: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112bb8: e8 63 1f 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 112bbd: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112bc0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 112bc3: e8 58 3d 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 112bc8: 58 pop %eax <== NOT EXECUTED 112bc9: 5a pop %edx <== NOT EXECUTED 112bca: 53 push %ebx <== NOT EXECUTED 112bcb: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112bd0: e8 e7 21 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 112bd5: e8 12 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112bda: 31 c0 xor %eax,%eax <== NOT EXECUTED 112bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bdf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112be2: c9 leave <== NOT EXECUTED 112be3: c3 ret <== NOT EXECUTED 00112be4 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 112be4: 55 push %ebp <== NOT EXECUTED 112be5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112be7: 57 push %edi <== NOT EXECUTED 112be8: 56 push %esi <== NOT EXECUTED 112be9: 53 push %ebx <== NOT EXECUTED 112bea: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112bed: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 112bf0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 112bf5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112bf9: 0f 84 8e 00 00 00 je 112c8d <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 112bff: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112c04: 85 ff test %edi,%edi <== NOT EXECUTED 112c06: 0f 84 81 00 00 00 je 112c8d <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112c0c: 52 push %edx <== NOT EXECUTED 112c0d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112c10: 50 push %eax <== NOT EXECUTED 112c11: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112c14: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112c19: e8 0e 23 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112c1e: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112c20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112c23: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112c28: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112c2c: 75 5f jne 112c8d <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112c2e: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 112c31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112c34: 56 push %esi <== NOT EXECUTED 112c35: e8 e6 3c 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 112c3a: 9c pushf <== NOT EXECUTED 112c3b: fa cli <== NOT EXECUTED 112c3c: 5a pop %edx <== 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 ) { 112c3d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112c40: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 112c44: 74 0b je 112c51 <== NOT EXECUTED _ISR_Enable( level ); 112c46: 52 push %edx <== NOT EXECUTED 112c47: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 112c48: e8 9f 2a 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112c4d: 31 c0 xor %eax,%eax <== NOT EXECUTED 112c4f: eb 3c jmp 112c8d <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 112c51: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112c58: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112c5f: 89 7b 2c mov %edi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112c62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112c65: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 112c68: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112c6b: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 112c6e: 52 push %edx <== NOT EXECUTED 112c6f: 9d popf <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 112c70: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112c73: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 112c76: 50 push %eax <== NOT EXECUTED 112c77: 50 push %eax <== NOT EXECUTED 112c78: 56 push %esi <== NOT EXECUTED 112c79: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 112c7e: e8 85 3b 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 112c83: e8 64 2a 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112c88: 31 c0 xor %eax,%eax <== NOT EXECUTED 112c8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112c8d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112c90: 5b pop %ebx <== NOT EXECUTED 112c91: 5e pop %esi <== NOT EXECUTED 112c92: 5f pop %edi <== NOT EXECUTED 112c93: c9 leave <== NOT EXECUTED 112c94: c3 ret <== NOT EXECUTED 00112c98 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112c98: 55 push %ebp <== NOT EXECUTED 112c99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112c9b: 57 push %edi <== NOT EXECUTED 112c9c: 56 push %esi <== NOT EXECUTED 112c9d: 53 push %ebx <== NOT EXECUTED 112c9e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112ca1: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 112ca4: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112ca9: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4 <== NOT EXECUTED 112cb0: 0f 84 ae 00 00 00 je 112d64 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 112cb6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112cb9: 53 push %ebx <== NOT EXECUTED 112cba: e8 85 da ff ff call 110744 <_TOD_Validate> <== NOT EXECUTED 112cbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112cc2: 84 c0 test %al,%al <== NOT EXECUTED 112cc4: 0f 84 95 00 00 00 je 112d5f <== NOT EXECUTED return RTEMS_INVALID_CLOCK; if ( !routine ) 112cca: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112ccf: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 112cd3: 0f 84 8b 00 00 00 je 112d64 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 112cd9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112cdc: 53 push %ebx <== NOT EXECUTED 112cdd: e8 fa d9 ff ff call 1106dc <_TOD_To_seconds> <== NOT EXECUTED 112ce2: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 112ce4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ce7: 3b 05 70 28 13 00 cmp 0x132870,%eax <== NOT EXECUTED 112ced: 76 70 jbe 112d5f <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112cef: 51 push %ecx <== NOT EXECUTED 112cf0: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112cf3: 50 push %eax <== NOT EXECUTED 112cf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112cf7: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112cfc: e8 2b 22 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112d01: 89 c6 mov %eax,%esi <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112d03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d06: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112d0b: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112d0f: 75 53 jne 112d64 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112d11: 8d 5e 10 lea 0x10(%esi),%ebx <== NOT EXECUTED 112d14: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112d17: 53 push %ebx <== NOT EXECUTED 112d18: e8 03 3c 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY; 112d1d: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112d24: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112d2b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112d2e: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112d31: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112d34: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED * the heap 112d37: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112d3a: 89 46 34 mov %eax,0x34(%esi) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 112d3d: 2b 3d 70 28 13 00 sub 0x132870,%edi <== NOT EXECUTED 112d43: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED size_t size ); 112d46: 58 pop %eax <== NOT EXECUTED 112d47: 5a pop %edx <== NOT EXECUTED 112d48: 53 push %ebx <== NOT EXECUTED 112d49: 68 b4 28 13 00 push $0x1328b4 <== NOT EXECUTED 112d4e: e8 b5 3a 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 112d53: e8 94 29 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112d58: 31 c0 xor %eax,%eax <== NOT EXECUTED 112d5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d5d: eb 05 jmp 112d64 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 112d5f: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112d64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112d67: 5b pop %ebx <== NOT EXECUTED 112d68: 5e pop %esi <== NOT EXECUTED 112d69: 5f pop %edi <== NOT EXECUTED 112d6a: c9 leave <== NOT EXECUTED 112d6b: c3 ret <== NOT EXECUTED 00112d6c : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 112d6c: 55 push %ebp <== NOT EXECUTED 112d6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112d6f: 53 push %ebx <== NOT EXECUTED 112d70: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 112d73: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 112d76: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112d7b: 85 db test %ebx,%ebx <== NOT EXECUTED 112d7d: 74 40 je 112dbf <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112d7f: 50 push %eax <== NOT EXECUTED 112d80: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112d83: 50 push %eax <== NOT EXECUTED 112d84: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112d87: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112d8c: e8 9b 21 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112d91: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112d93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d96: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112d9b: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112d9f: 75 1e jne 112dbf <== NOT EXECUTED case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 112da1: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 112da4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 112da6: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 112da9: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 112dac: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 112daf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 112db2: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 112db5: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112db8: e8 2f 29 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112dbd: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112dbf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112dc2: c9 leave <== NOT EXECUTED 112dc3: c3 ret <== NOT EXECUTED 00112dc4 : rtems_status_code rtems_timer_ident( rtems_name name, Objects_Id *id ) { 112dc4: 55 push %ebp <== NOT EXECUTED 112dc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112dc7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 112dca: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112dcd: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 112dd2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112dd5: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112dda: e8 95 22 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 112ddf: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 112de6: c9 leave <== NOT EXECUTED 112de7: c3 ret <== NOT EXECUTED 0011301c : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 11301c: 55 push %ebp <== NOT EXECUTED 11301d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11301f: 57 push %edi <== NOT EXECUTED 113020: 56 push %esi <== NOT EXECUTED 113021: 53 push %ebx <== NOT EXECUTED 113022: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 113028: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 11302b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11302d: 85 d2 test %edx,%edx <== NOT EXECUTED 11302f: 74 0f je 113040 <== NOT EXECUTED 113031: 0f b6 05 e4 a0 12 00 movzbl 0x12a0e4,%eax <== NOT EXECUTED 113038: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11303a: 0f 96 c0 setbe %al <== NOT EXECUTED 11303d: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED * Make sure the requested priority is valid. The if is * 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 ) ) { 113040: 89 d7 mov %edx,%edi <== NOT EXECUTED 113042: 85 c0 test %eax,%eax <== NOT EXECUTED 113044: 75 0e jne 113054 <== NOT EXECUTED if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 113046: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 11304b: 42 inc %edx <== NOT EXECUTED 11304c: 0f 85 31 01 00 00 jne 113183 <== NOT EXECUTED 113052: 31 ff xor %edi,%edi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113054: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 113059: 40 inc %eax <== NOT EXECUTED 11305a: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 11305f: 8a 1d 54 e2 12 00 mov 0x12e254,%bl <== NOT EXECUTED initialized = true; 113065: c6 05 54 e2 12 00 01 movb $0x1,0x12e254 <== NOT EXECUTED _Thread_Enable_dispatch(); 11306c: e8 7b 26 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 113071: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 113076: 84 db test %bl,%bl <== NOT EXECUTED 113078: 0f 85 05 01 00 00 jne 113183 <== NOT EXECUTED 11307e: c7 05 74 27 13 00 78 movl $0x132778,0x132774 <== NOT EXECUTED 113085: 27 13 00 <== NOT EXECUTED 113088: c7 05 78 27 13 00 00 movl $0x0,0x132778 <== NOT EXECUTED 11308f: 00 00 00 <== NOT EXECUTED 113092: c7 05 7c 27 13 00 74 movl $0x132774,0x13277c <== NOT EXECUTED 113099: 27 13 00 <== NOT EXECUTED * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 11309c: 52 push %edx <== NOT EXECUTED 11309d: 52 push %edx <== NOT EXECUTED 11309e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1130a1: 50 push %eax <== NOT EXECUTED 1130a2: 81 ce 00 80 00 00 or $0x8000,%esi <== NOT EXECUTED 1130a8: 56 push %esi <== NOT EXECUTED 1130a9: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 1130ae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1130b1: 57 push %edi <== NOT EXECUTED 1130b2: 68 45 4d 49 54 push $0x54494d45 <== NOT EXECUTED 1130b7: e8 70 f3 ff ff call 11242c <== NOT EXECUTED /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 1130bc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1130bf: 85 c0 test %eax,%eax <== NOT EXECUTED 1130c1: 0f 85 b5 00 00 00 jne 11317c <== NOT EXECUTED * to a TCB pointer from here out. * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 1130c7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 1130ca: 31 c0 xor %eax,%eax <== NOT EXECUTED 1130cc: 66 3b 0d 24 27 13 00 cmp 0x132724,%cx <== NOT EXECUTED 1130d3: 77 0b ja 1130e0 <== NOT EXECUTED * This heap routine returns information about the free blocks * in the specified heap. 1130d5: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1130d8: a1 30 27 13 00 mov 0x132730,%eax <== NOT EXECUTED 1130dd: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 1130e0: a3 18 2b 13 00 mov %eax,0x132b18 <== NOT EXECUTED 1130e5: c7 05 54 27 13 00 58 movl $0x132758,0x132754 <== NOT EXECUTED 1130ec: 27 13 00 <== NOT EXECUTED 1130ef: c7 05 58 27 13 00 00 movl $0x0,0x132758 <== NOT EXECUTED 1130f6: 00 00 00 <== NOT EXECUTED 1130f9: c7 05 5c 27 13 00 54 movl $0x132754,0x13275c <== NOT EXECUTED 113100: 27 13 00 <== NOT EXECUTED 113103: c7 05 68 27 13 00 6c movl $0x13276c,0x132768 <== NOT EXECUTED 11310a: 27 13 00 <== NOT EXECUTED 11310d: c7 05 6c 27 13 00 00 movl $0x0,0x13276c <== NOT EXECUTED 113114: 00 00 00 <== NOT EXECUTED 113117: c7 05 70 27 13 00 68 movl $0x132768,0x132770 <== NOT EXECUTED 11311e: 27 13 00 <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113121: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 113128: c7 40 64 70 55 11 00 movl $0x115570,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11312f: 89 48 68 mov %ecx,0x68(%eax) <== NOT EXECUTED * the heap 113132: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113139: c7 05 88 27 13 00 00 movl $0x0,0x132788 <== NOT EXECUTED 113140: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 113143: c7 05 9c 27 13 00 70 movl $0x115570,0x13279c <== NOT EXECUTED 11314a: 55 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11314d: 89 0d a0 27 13 00 mov %ecx,0x1327a0 <== NOT EXECUTED * the heap 113153: c7 05 a4 27 13 00 00 movl $0x0,0x1327a4 <== NOT EXECUTED 11315a: 00 00 00 <== NOT EXECUTED /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 11315d: c7 05 14 2b 13 00 8b movl $0x11318b,0x132b14 <== NOT EXECUTED 113164: 31 11 00 <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 113167: 50 push %eax <== NOT EXECUTED 113168: 6a 00 push $0x0 <== NOT EXECUTED 11316a: 68 14 32 11 00 push $0x113214 <== NOT EXECUTED 11316f: 51 push %ecx <== NOT EXECUTED 113170: e8 53 f7 ff ff call 1128c8 <== NOT EXECUTED id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 113175: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113178: 85 c0 test %eax,%eax <== NOT EXECUTED 11317a: 74 07 je 113183 <== NOT EXECUTED * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 11317c: c6 05 54 e2 12 00 00 movb $0x0,0x12e254 <== NOT EXECUTED } return status; } 113183: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113186: 5b pop %ebx <== NOT EXECUTED 113187: 5e pop %esi <== NOT EXECUTED 113188: 5f pop %edi <== NOT EXECUTED 113189: c9 leave <== NOT EXECUTED 11318a: c3 ret <== NOT EXECUTED 00112de8 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 112de8: 55 push %ebp <== NOT EXECUTED 112de9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112deb: 53 push %ebx <== NOT EXECUTED 112dec: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 112def: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112df2: 50 push %eax <== NOT EXECUTED 112df3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112df6: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112dfb: e8 2c 21 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112e00: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112e02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112e05: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112e0a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112e0e: 75 6e jne 112e7e <== NOT EXECUTED case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 112e10: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 112e13: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 112e16: 74 24 je 112e3c <== NOT EXECUTED 112e18: 72 07 jb 112e21 <== NOT EXECUTED 112e1a: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 112e1d: 77 58 ja 112e77 <== NOT EXECUTED 112e1f: eb 4a jmp 112e6b <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 112e21: 83 c3 10 add $0x10,%ebx <== NOT EXECUTED 112e24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112e27: 53 push %ebx <== NOT EXECUTED 112e28: e8 f3 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 112e2d: 58 pop %eax <== NOT EXECUTED 112e2e: 5a pop %edx <== NOT EXECUTED 112e2f: 53 push %ebx <== NOT EXECUTED 112e30: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 112e35: e8 ce 39 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 112e3a: eb 2a jmp 112e66 <== NOT EXECUTED break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 112e3c: 83 3d 14 2b 13 00 00 cmpl $0x0,0x132b14 <== NOT EXECUTED 112e43: 75 0c jne 112e51 <== NOT EXECUTED _Thread_Enable_dispatch(); 112e45: e8 a2 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e4a: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112e4f: eb 2d jmp 112e7e <== NOT EXECUTED return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 112e51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112e54: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112e57: 50 push %eax <== NOT EXECUTED 112e58: e8 c3 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 112e5d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 112e60: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED 112e66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112e69: eb 0c jmp 112e77 <== NOT EXECUTED break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 112e6b: e8 7c 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e70: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112e75: eb 07 jmp 112e7e <== NOT EXECUTED return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 112e77: e8 70 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e7c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112e7e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112e81: c9 leave <== NOT EXECUTED 112e82: c3 ret <== NOT EXECUTED 00112e84 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 112e84: 55 push %ebp <== NOT EXECUTED 112e85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112e87: 57 push %edi <== NOT EXECUTED 112e88: 56 push %esi <== NOT EXECUTED 112e89: 53 push %ebx <== NOT EXECUTED 112e8a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112e8d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 112e90: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 112e93: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112e98: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18 <== NOT EXECUTED 112e9f: 0f 84 91 00 00 00 je 112f36 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 112ea5: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112eaa: 85 f6 test %esi,%esi <== NOT EXECUTED 112eac: 0f 84 84 00 00 00 je 112f36 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 112eb2: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 112eb7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112ebb: 74 79 je 112f36 <== NOT EXECUTED 112ebd: 50 push %eax <== NOT EXECUTED 112ebe: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112ec1: 50 push %eax <== NOT EXECUTED 112ec2: 57 push %edi <== NOT EXECUTED 112ec3: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112ec8: e8 5f 20 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ecd: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ecf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ed2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112ed7: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112edb: 75 59 jne 112f36 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112edd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112ee0: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112ee3: 50 push %eax <== NOT EXECUTED 112ee4: e8 37 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 112ee9: 9c pushf <== NOT EXECUTED 112eea: fa cli <== NOT EXECUTED 112eeb: 5a pop %edx <== 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 ) { 112eec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112eef: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 112ef3: 74 0b je 112f00 <== NOT EXECUTED _ISR_Enable( level ); 112ef5: 52 push %edx <== NOT EXECUTED 112ef6: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 112ef7: e8 f0 27 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112efc: 31 c0 xor %eax,%eax <== NOT EXECUTED 112efe: eb 36 jmp 112f36 <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 112f00: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112f07: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112f0e: 89 73 2c mov %esi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112f11: 89 7b 30 mov %edi,0x30(%ebx) <== NOT EXECUTED * the heap 112f14: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112f17: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 112f1a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112f1d: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 112f20: 52 push %edx <== NOT EXECUTED 112f21: 9d popf <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 112f22: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f25: 53 push %ebx <== NOT EXECUTED 112f26: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED _Thread_Enable_dispatch(); 112f2c: e8 bb 27 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112f31: 31 c0 xor %eax,%eax <== NOT EXECUTED 112f33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112f36: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112f39: 5b pop %ebx <== NOT EXECUTED 112f3a: 5e pop %esi <== NOT EXECUTED 112f3b: 5f pop %edi <== NOT EXECUTED 112f3c: c9 leave <== NOT EXECUTED 112f3d: c3 ret <== NOT EXECUTED 00112f40 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112f40: 55 push %ebp <== NOT EXECUTED 112f41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f43: 57 push %edi <== NOT EXECUTED 112f44: 56 push %esi <== NOT EXECUTED 112f45: 53 push %ebx <== NOT EXECUTED 112f46: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112f49: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 112f4c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 112f4f: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112f54: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18 <== NOT EXECUTED 112f5b: 0f 84 b3 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 112f61: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112f66: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4 <== NOT EXECUTED 112f6d: 0f 84 a1 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 112f73: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112f78: 85 ff test %edi,%edi <== NOT EXECUTED 112f7a: 0f 84 94 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 112f80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f83: 53 push %ebx <== NOT EXECUTED 112f84: e8 bb d7 ff ff call 110744 <_TOD_Validate> <== NOT EXECUTED 112f89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f8c: 84 c0 test %al,%al <== NOT EXECUTED 112f8e: 74 7f je 11300f <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 112f90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f93: 53 push %ebx <== NOT EXECUTED 112f94: e8 43 d7 ff ff call 1106dc <_TOD_To_seconds> <== NOT EXECUTED 112f99: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 112f9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f9e: 3b 05 70 28 13 00 cmp 0x132870,%eax <== NOT EXECUTED 112fa4: 76 69 jbe 11300f <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112fa6: 50 push %eax <== NOT EXECUTED 112fa7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112faa: 50 push %eax <== NOT EXECUTED 112fab: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112fae: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112fb3: e8 74 1f 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112fb8: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112fba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112fbd: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112fc2: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112fc6: 75 4c jne 113014 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112fc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112fcb: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112fce: 50 push %eax <== NOT EXECUTED 112fcf: e8 4c 39 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 112fd4: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112fdb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112fe2: 89 7b 2c mov %edi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112fe5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112fe8: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 112feb: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112fee: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 112ff1: 2b 35 70 28 13 00 sub 0x132870,%esi <== NOT EXECUTED 112ff7: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 112ffa: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 112ffd: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED _Thread_Enable_dispatch(); 113003: e8 e4 26 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 113008: 31 c0 xor %eax,%eax <== NOT EXECUTED 11300a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11300d: eb 05 jmp 113014 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11300f: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113014: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113017: 5b pop %ebx <== NOT EXECUTED 113018: 5e pop %esi <== NOT EXECUTED 113019: 5f pop %edi <== NOT EXECUTED 11301a: c9 leave <== NOT EXECUTED 11301b: c3 ret <== NOT EXECUTED 00109429 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 109429: 55 push %ebp <== NOT EXECUTED 10942a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10942c: 57 push %edi <== NOT EXECUTED 10942d: 56 push %esi <== NOT EXECUTED 10942e: 53 push %ebx <== NOT EXECUTED 10942f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109432: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 109435: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 109438: 89 cb mov %ecx,%ebx <== NOT EXECUTED int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) 10943a: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 10943f: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 109442: 74 2a je 10946e <== NOT EXECUTED { if (rtems_panic_in_progress++) 109444: 8b 15 20 87 12 00 mov 0x128720,%edx <== NOT EXECUTED 10944a: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10944d: a3 20 87 12 00 mov %eax,0x128720 <== NOT EXECUTED 109452: 85 d2 test %edx,%edx <== NOT EXECUTED 109454: 74 0b je 109461 <== NOT EXECUTED 109456: a1 84 88 12 00 mov 0x128884,%eax <== NOT EXECUTED 10945b: 40 inc %eax <== NOT EXECUTED 10945c: a3 84 88 12 00 mov %eax,0x128884 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 109461: 83 3d 20 87 12 00 02 cmpl $0x2,0x128720 <== NOT EXECUTED 109468: 0f 8f 18 01 00 00 jg 109586 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10946e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109471: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 109476: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109479: e8 da c0 00 00 call 115558 <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 10947e: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED 109481: 81 e6 ff ff ff 8f and $0x8fffffff,%esi <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 109487: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10948a: 31 ff xor %edi,%edi <== NOT EXECUTED 10948c: f7 45 ec 00 00 00 40 testl $0x40000000,-0x14(%ebp) <== NOT EXECUTED 109493: 74 07 je 10949c <== NOT EXECUTED local_errno = errno; 109495: e8 0e be 00 00 call 1152a8 <__errno> <== NOT EXECUTED 10949a: 8b 38 mov (%eax),%edi <== 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); 10949c: 50 push %eax <== NOT EXECUTED 10949d: 53 push %ebx <== NOT EXECUTED 10949e: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 1094a1: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 1094a6: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1094a9: e8 be 16 01 00 call 11ab6c <== NOT EXECUTED 1094ae: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (status) 1094b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094b3: 85 f6 test %esi,%esi <== NOT EXECUTED 1094b5: 74 28 je 1094df <== NOT EXECUTED const char * rtems_status_text( rtems_status_code status ) { return rtems_assoc_name_by_local(rtems_status_assoc, status); 1094b7: 50 push %eax <== NOT EXECUTED 1094b8: 50 push %eax <== NOT EXECUTED 1094b9: 56 push %esi <== NOT EXECUTED 1094ba: 68 8c fa 11 00 push $0x11fa8c <== NOT EXECUTED 1094bf: e8 10 85 00 00 call 1119d4 <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 1094c4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1094c7: 50 push %eax <== NOT EXECUTED 1094c8: 68 7f f7 11 00 push $0x11f77f <== NOT EXECUTED 1094cd: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 1094d2: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1094d5: e8 e2 c5 00 00 call 115abc <== NOT EXECUTED 1094da: 01 c3 add %eax,%ebx <== NOT EXECUTED 1094dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (local_errno) 1094df: 83 ff 00 cmp $0x0,%edi <== NOT EXECUTED 1094e2: 74 40 je 109524 <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 1094e4: 7e 25 jle 10950b <== NOT EXECUTED 1094e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094e9: 57 push %edi <== NOT EXECUTED 1094ea: e8 d1 eb 00 00 call 1180c0 <== NOT EXECUTED 1094ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094f2: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 1094f5: 74 14 je 10950b <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 1094f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094fa: 57 push %edi <== NOT EXECUTED 1094fb: e8 c0 eb 00 00 call 1180c0 <== NOT EXECUTED 109500: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109503: 50 push %eax <== NOT EXECUTED 109504: 68 8d f7 11 00 push $0x11f78d <== NOT EXECUTED 109509: eb 07 jmp 109512 <== NOT EXECUTED else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10950b: 50 push %eax <== NOT EXECUTED 10950c: 57 push %edi <== NOT EXECUTED 10950d: 68 9a f7 11 00 push $0x11f79a <== NOT EXECUTED 109512: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 109517: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10951a: e8 9d c5 00 00 call 115abc <== NOT EXECUTED 10951f: 01 c3 add %eax,%ebx <== NOT EXECUTED 109521: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 109524: 56 push %esi <== NOT EXECUTED 109525: 56 push %esi <== NOT EXECUTED 109526: 68 ad ff 11 00 push $0x11ffad <== NOT EXECUTED 10952b: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 109530: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 109533: e8 84 c5 00 00 call 115abc <== NOT EXECUTED 109538: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) fflush(stderr); 10953a: 59 pop %ecx <== NOT EXECUTED 10953b: a1 40 61 12 00 mov 0x126140,%eax <== NOT EXECUTED 109540: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 109543: e8 10 c0 00 00 call 115558 <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 109548: 83 c4 10 add $0x10,%esp <== 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"); 10954b: 8d 04 1e lea (%esi,%ebx,1),%eax <== NOT EXECUTED (void) fflush(stderr); if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 10954e: f7 45 ec 00 00 00 30 testl $0x30000000,-0x14(%ebp) <== NOT EXECUTED 109555: 74 31 je 109588 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 109557: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10955b: 74 16 je 109573 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 10955d: 52 push %edx <== NOT EXECUTED 10955e: 52 push %edx <== NOT EXECUTED 10955f: 68 ae f7 11 00 push $0x11f7ae <== NOT EXECUTED 109564: 6a 00 push $0x0 <== NOT EXECUTED 109566: e8 3d 00 00 00 call 1095a8 <== NOT EXECUTED _exit(local_errno); 10956b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10956e: e8 df 05 00 00 call 109b52 <_exit> <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); 109573: 50 push %eax <== NOT EXECUTED 109574: 50 push %eax <== NOT EXECUTED 109575: 68 c3 f7 11 00 push $0x11f7c3 <== NOT EXECUTED 10957a: 6a 00 push $0x0 <== NOT EXECUTED 10957c: e8 27 00 00 00 call 1095a8 <== NOT EXECUTED abort(); 109581: e8 ee bc 00 00 call 115274 <== NOT EXECUTED 109586: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 109588: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10958b: 5b pop %ebx <== NOT EXECUTED 10958c: 5e pop %esi <== NOT EXECUTED 10958d: 5f pop %edi <== NOT EXECUTED 10958e: c9 leave <== NOT EXECUTED 10958f: c3 ret <== NOT EXECUTED 0011f5d2 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 11f5d2: 55 push %ebp <== NOT EXECUTED 11f5d3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f5d5: 57 push %edi <== NOT EXECUTED 11f5d6: 56 push %esi <== NOT EXECUTED 11f5d7: 53 push %ebx <== NOT EXECUTED 11f5d8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11f5db: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f5dd: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 11f5e0: 31 ff xor %edi,%edi <== NOT EXECUTED 11f5e2: c7 45 f0 ff ff ff 7f movl $0x7fffffff,-0x10(%ebp) <== NOT EXECUTED 11f5e9: 31 db xor %ebx,%ebx <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 11f5eb: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 11f5ee: 48 dec %eax <== NOT EXECUTED 11f5ef: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 11f5f2: 85 c0 test %eax,%eax <== NOT EXECUTED 11f5f4: 79 16 jns 11f60c <== NOT EXECUTED 11f5f6: 50 push %eax <== NOT EXECUTED 11f5f7: 50 push %eax <== NOT EXECUTED 11f5f8: 56 push %esi <== NOT EXECUTED 11f5f9: ff 35 40 4a 14 00 pushl 0x144a40 <== NOT EXECUTED 11f5ff: e8 28 f2 00 00 call 12e82c <__srget_r> <== NOT EXECUTED 11f604: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 11f607: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f60a: eb 0b jmp 11f617 <== NOT EXECUTED 11f60c: 8b 06 mov (%esi),%eax <== NOT EXECUTED 11f60e: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 11f611: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 11f614: 40 inc %eax <== NOT EXECUTED 11f615: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') 11f617: 83 7d e8 3a cmpl $0x3a,-0x18(%ebp) <== NOT EXECUTED 11f61b: 74 4c je 11f669 <== NOT EXECUTED break; if (sign == 0) { 11f61d: 85 db test %ebx,%ebx <== NOT EXECUTED 11f61f: 75 10 jne 11f631 <== NOT EXECUTED if (c == '-') { sign = -1; limit++; continue; 11f621: b3 01 mov $0x1,%bl <== NOT EXECUTED for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 11f623: 83 7d e8 2d cmpl $0x2d,-0x18(%ebp) <== NOT EXECUTED 11f627: 75 08 jne 11f631 <== NOT EXECUTED sign = -1; limit++; 11f629: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED 11f62c: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11f62f: eb ba jmp 11f5eb <== NOT EXECUTED continue; } sign = 1; } if (!isdigit(c)) 11f631: a1 24 4a 14 00 mov 0x144a24,%eax <== NOT EXECUTED 11f636: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 11f639: f6 04 08 04 testb $0x4,(%eax,%ecx,1) <== NOT EXECUTED 11f63d: 74 3d je 11f67c <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 11f63f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f642: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 11f647: 31 d2 xor %edx,%edx <== NOT EXECUTED 11f649: f7 f1 div %ecx <== NOT EXECUTED 11f64b: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 11f64e: 39 c7 cmp %eax,%edi <== NOT EXECUTED 11f650: 77 2a ja 11f67c <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 11f652: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11f655: 83 ea 30 sub $0x30,%edx <== NOT EXECUTED if ((i > (limit / 10)) 11f658: 39 c7 cmp %eax,%edi <== NOT EXECUTED 11f65a: 75 05 jne 11f661 <== NOT EXECUTED 11f65c: 3b 55 e4 cmp -0x1c(%ebp),%edx <== NOT EXECUTED 11f65f: 77 1b ja 11f67c <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 11f661: 6b c7 0a imul $0xa,%edi,%eax <== NOT EXECUTED 11f664: 8d 3c 02 lea (%edx,%eax,1),%edi <== NOT EXECUTED 11f667: eb 82 jmp 11f5eb <== NOT EXECUTED } if (sign == 0) 11f669: 85 db test %ebx,%ebx <== NOT EXECUTED 11f66b: 74 0f je 11f67c <== NOT EXECUTED return 0; *val = i * sign; 11f66d: 0f af df imul %edi,%ebx <== NOT EXECUTED 11f670: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f673: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 11f675: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f67a: eb 02 jmp 11f67e <== NOT EXECUTED return 1; 11f67c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f67e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f681: 5b pop %ebx <== NOT EXECUTED 11f682: 5e pop %esi <== NOT EXECUTED 11f683: 5f pop %edi <== NOT EXECUTED 11f684: c9 leave <== NOT EXECUTED 11f685: c3 ret <== NOT EXECUTED 0011f686 : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 11f686: 55 push %ebp <== NOT EXECUTED 11f687: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f689: 57 push %edi <== NOT EXECUTED 11f68a: 56 push %esi <== NOT EXECUTED 11f68b: 53 push %ebx <== NOT EXECUTED 11f68c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f68f: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f691: 89 cb mov %ecx,%ebx <== NOT EXECUTED 11f693: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED int c; *name = *bufp; 11f696: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 11f698: 89 02 mov %eax,(%edx) <== NOT EXECUTED for (;;) { c = getc(fp); 11f69a: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 11f69d: 48 dec %eax <== NOT EXECUTED 11f69e: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 11f6a1: 85 c0 test %eax,%eax <== NOT EXECUTED 11f6a3: 79 15 jns 11f6ba <== NOT EXECUTED 11f6a5: 52 push %edx <== NOT EXECUTED 11f6a6: 52 push %edx <== NOT EXECUTED 11f6a7: 56 push %esi <== NOT EXECUTED 11f6a8: ff 35 40 4a 14 00 pushl 0x144a40 <== NOT EXECUTED 11f6ae: e8 79 f1 00 00 call 12e82c <__srget_r> <== NOT EXECUTED 11f6b3: 89 c2 mov %eax,%edx <== NOT EXECUTED 11f6b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f6b8: eb 08 jmp 11f6c2 <== NOT EXECUTED 11f6ba: 8b 06 mov (%esi),%eax <== NOT EXECUTED 11f6bc: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 11f6bf: 40 inc %eax <== NOT EXECUTED 11f6c0: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') { 11f6c2: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 11f6c5: 75 08 jne 11f6cf <== NOT EXECUTED if (nlFlag) 11f6c7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11f6cb: 74 23 je 11f6f0 <== NOT EXECUTED 11f6cd: eb 31 jmp 11f700 <== NOT EXECUTED return 0; break; } if (c == '\n') { 11f6cf: 83 fa 0a cmp $0xa,%edx <== NOT EXECUTED 11f6d2: 75 08 jne 11f6dc <== NOT EXECUTED if (!nlFlag) 11f6d4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11f6d8: 75 16 jne 11f6f0 <== NOT EXECUTED 11f6da: eb 24 jmp 11f700 <== NOT EXECUTED return 0; break; } if (c == EOF) 11f6dc: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED 11f6df: 74 1f je 11f700 <== NOT EXECUTED return 0; if (*nleft < 2) 11f6e1: 83 3f 01 cmpl $0x1,(%edi) <== NOT EXECUTED 11f6e4: 76 1a jbe 11f700 <== NOT EXECUTED return 0; **bufp = c; 11f6e6: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 11f6e8: 88 10 mov %dl,(%eax) <== NOT EXECUTED ++(*bufp); 11f6ea: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 11f6ec: ff 0f decl (%edi) <== NOT EXECUTED 11f6ee: eb aa jmp 11f69a <== NOT EXECUTED } **bufp = '\0'; 11f6f0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 11f6f2: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED ++(*bufp); 11f6f5: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 11f6f7: ff 0f decl (%edi) <== NOT EXECUTED 11f6f9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f6fe: eb 02 jmp 11f702 <== NOT EXECUTED return 1; 11f700: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f702: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f705: 5b pop %ebx <== NOT EXECUTED 11f706: 5e pop %esi <== NOT EXECUTED 11f707: 5f pop %edi <== NOT EXECUTED 11f708: c9 leave <== NOT EXECUTED 11f709: c3 ret <== NOT EXECUTED 0011f70a : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 11f70a: 55 push %ebp <== NOT EXECUTED 11f70b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f70d: 57 push %edi <== NOT EXECUTED 11f70e: 56 push %esi <== NOT EXECUTED 11f70f: 53 push %ebx <== NOT EXECUTED 11f710: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 11f713: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f715: 89 d6 mov %edx,%esi <== NOT EXECUTED 11f717: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 11f71a: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 11f71d: 6a 00 push $0x0 <== NOT EXECUTED 11f71f: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f722: 50 push %eax <== NOT EXECUTED 11f723: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f725: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f727: e8 5a ff ff ff call 11f686 <== NOT EXECUTED 11f72c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f72f: 85 c0 test %eax,%eax <== NOT EXECUTED 11f731: 0f 84 bf 00 00 00 je 11f7f6 <== NOT EXECUTED 11f737: 50 push %eax <== NOT EXECUTED 11f738: 50 push %eax <== NOT EXECUTED 11f739: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 11f73c: 6a 00 push $0x0 <== NOT EXECUTED 11f73e: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f741: 50 push %eax <== NOT EXECUTED 11f742: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f744: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f746: e8 3b ff ff ff call 11f686 <== NOT EXECUTED 11f74b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f74e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f750: 0f 84 a0 00 00 00 je 11f7f6 <== NOT EXECUTED 11f756: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 11f759: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f75b: e8 72 fe ff ff call 11f5d2 <== NOT EXECUTED 11f760: 85 c0 test %eax,%eax <== NOT EXECUTED 11f762: 0f 84 8e 00 00 00 je 11f7f6 <== NOT EXECUTED 11f768: 51 push %ecx <== NOT EXECUTED 11f769: 51 push %ecx <== NOT EXECUTED 11f76a: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 11f76d: 6a 01 push $0x1 <== NOT EXECUTED 11f76f: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f772: 50 push %eax <== NOT EXECUTED 11f773: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f775: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f777: e8 0a ff ff ff call 11f686 <== NOT EXECUTED 11f77c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f77f: 85 c0 test %eax,%eax <== NOT EXECUTED 11f781: 74 73 je 11f7f6 <== NOT EXECUTED || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; grp->gr_gid = grgid; 11f783: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f786: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f78a: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 11f78d: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 11f78f: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 11f794: eb 0b jmp 11f7a1 <== NOT EXECUTED if(*cp == ',') memcount++; 11f796: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 11f798: 0f 94 c0 sete %al <== NOT EXECUTED 11f79b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 11f79e: 01 c2 add %eax,%edx <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f7a0: 41 inc %ecx <== NOT EXECUTED 11f7a1: 8a 01 mov (%ecx),%al <== NOT EXECUTED 11f7a3: 84 c0 test %al,%al <== NOT EXECUTED 11f7a5: 75 ef jne 11f796 <== NOT EXECUTED } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 11f7a7: 8d 04 95 13 00 00 00 lea 0x13(,%edx,4),%eax <== NOT EXECUTED 11f7ae: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 11f7b1: 72 43 jb 11f7f6 <== NOT EXECUTED return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 11f7b3: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11f7b6: 83 c0 0f add $0xf,%eax <== NOT EXECUTED 11f7b9: 83 e0 f0 and $0xfffffff0,%eax <== NOT EXECUTED 11f7bc: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 11f7bf: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 11f7c1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f7c4: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 11f7c7: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 11f7cc: eb 10 jmp 11f7de <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { if(*cp == ',') { 11f7ce: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 11f7d0: 75 0b jne 11f7dd <== NOT EXECUTED *cp = '\0'; 11f7d2: c6 42 ff 00 movb $0x0,-0x1(%edx) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 11f7d6: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 11f7d9: 89 14 88 mov %edx,(%eax,%ecx,4) <== NOT EXECUTED 11f7dc: 41 inc %ecx <== NOT EXECUTED 11f7dd: 42 inc %edx <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f7de: 8a 42 ff mov -0x1(%edx),%al <== NOT EXECUTED 11f7e1: 84 c0 test %al,%al <== NOT EXECUTED 11f7e3: 75 e9 jne 11f7ce <== NOT EXECUTED if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 11f7e5: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 11f7e8: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) <== NOT EXECUTED 11f7ef: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f7f4: eb 02 jmp 11f7f8 <== NOT EXECUTED return 1; 11f7f6: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f7f8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f7fb: 5b pop %ebx <== NOT EXECUTED 11f7fc: 5e pop %esi <== NOT EXECUTED 11f7fd: 5f pop %edi <== NOT EXECUTED 11f7fe: c9 leave <== NOT EXECUTED 11f7ff: c3 ret <== NOT EXECUTED 0011f838 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 11f838: 55 push %ebp <== NOT EXECUTED 11f839: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f83b: 57 push %edi <== NOT EXECUTED 11f83c: 56 push %esi <== NOT EXECUTED 11f83d: 53 push %ebx <== NOT EXECUTED 11f83e: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 11f841: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f843: 89 d6 mov %edx,%esi <== NOT EXECUTED 11f845: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 11f848: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 11f84b: 6a 00 push $0x0 <== NOT EXECUTED 11f84d: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f850: 50 push %eax <== NOT EXECUTED 11f851: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f853: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f855: e8 2c fe ff ff call 11f686 <== NOT EXECUTED 11f85a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f85d: 85 c0 test %eax,%eax <== NOT EXECUTED 11f85f: 0f 84 c4 00 00 00 je 11f929 <== NOT EXECUTED 11f865: 50 push %eax <== NOT EXECUTED 11f866: 50 push %eax <== NOT EXECUTED 11f867: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 11f86a: 6a 00 push $0x0 <== NOT EXECUTED 11f86c: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f86f: 50 push %eax <== NOT EXECUTED 11f870: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f872: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f874: e8 0d fe ff ff call 11f686 <== NOT EXECUTED 11f879: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f87c: 85 c0 test %eax,%eax <== NOT EXECUTED 11f87e: 0f 84 a5 00 00 00 je 11f929 <== NOT EXECUTED 11f884: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 11f887: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f889: e8 44 fd ff ff call 11f5d2 <== NOT EXECUTED 11f88e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f890: 0f 84 93 00 00 00 je 11f929 <== NOT EXECUTED 11f896: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 11f899: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f89b: e8 32 fd ff ff call 11f5d2 <== NOT EXECUTED 11f8a0: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8a2: 0f 84 81 00 00 00 je 11f929 <== NOT EXECUTED 11f8a8: 50 push %eax <== NOT EXECUTED 11f8a9: 50 push %eax <== NOT EXECUTED 11f8aa: 8d 56 0c lea 0xc(%esi),%edx <== NOT EXECUTED 11f8ad: 6a 00 push $0x0 <== NOT EXECUTED 11f8af: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f8b2: 50 push %eax <== NOT EXECUTED 11f8b3: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f8b5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f8b7: e8 ca fd ff ff call 11f686 <== NOT EXECUTED 11f8bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f8bf: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8c1: 74 66 je 11f929 <== NOT EXECUTED 11f8c3: 50 push %eax <== NOT EXECUTED 11f8c4: 50 push %eax <== NOT EXECUTED 11f8c5: 8d 56 10 lea 0x10(%esi),%edx <== NOT EXECUTED 11f8c8: 6a 00 push $0x0 <== NOT EXECUTED 11f8ca: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f8cd: 50 push %eax <== NOT EXECUTED 11f8ce: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f8d0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f8d2: e8 af fd ff ff call 11f686 <== NOT EXECUTED 11f8d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f8da: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8dc: 74 4b je 11f929 <== NOT EXECUTED 11f8de: 50 push %eax <== NOT EXECUTED 11f8df: 50 push %eax <== NOT EXECUTED 11f8e0: 8d 56 14 lea 0x14(%esi),%edx <== NOT EXECUTED 11f8e3: 6a 00 push $0x0 <== NOT EXECUTED 11f8e5: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f8e8: 50 push %eax <== NOT EXECUTED 11f8e9: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f8eb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f8ed: e8 94 fd ff ff call 11f686 <== NOT EXECUTED 11f8f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f8f5: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8f7: 74 30 je 11f929 <== NOT EXECUTED 11f8f9: 50 push %eax <== NOT EXECUTED 11f8fa: 50 push %eax <== NOT EXECUTED 11f8fb: 8d 56 18 lea 0x18(%esi),%edx <== NOT EXECUTED 11f8fe: 6a 01 push $0x1 <== NOT EXECUTED 11f900: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f903: 50 push %eax <== NOT EXECUTED 11f904: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f906: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f908: e8 79 fd ff ff call 11f686 <== NOT EXECUTED 11f90d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f910: 85 c0 test %eax,%eax <== NOT EXECUTED 11f912: 74 15 je 11f929 <== NOT EXECUTED || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) return 0; pwd->pw_uid = pwuid; 11f914: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f917: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED pwd->pw_gid = pwgid; 11f91b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f91e: 66 89 46 0a mov %ax,0xa(%esi) <== NOT EXECUTED 11f922: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f927: eb 02 jmp 11f92b <== NOT EXECUTED return 1; 11f929: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f92b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f92e: 5b pop %ebx <== NOT EXECUTED 11f92f: 5e pop %esi <== NOT EXECUTED 11f930: 5f pop %edi <== NOT EXECUTED 11f931: c9 leave <== NOT EXECUTED 11f932: c3 ret <== NOT EXECUTED 0011f581 : */ int setgid( gid_t gid ) { 11f581: 55 push %ebp <== NOT EXECUTED 11f582: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 11f584: 8b 15 84 3b 14 00 mov 0x143b84,%edx <== NOT EXECUTED 11f58a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f58d: 66 89 42 2c mov %ax,0x2c(%edx) <== NOT EXECUTED return 0; } 11f591: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f593: c9 leave <== NOT EXECUTED 11f594: c3 ret <== NOT EXECUTED 0011fa3c : return NULL; return &grent; } void setgrent(void) { 11fa3c: 55 push %ebp <== NOT EXECUTED 11fa3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fa3f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 11fa42: e8 24 ff ff ff call 11f96b <== NOT EXECUTED if (group_fp != NULL) 11fa47: a1 d4 91 15 00 mov 0x1591d4,%eax <== NOT EXECUTED 11fa4c: 85 c0 test %eax,%eax <== NOT EXECUTED 11fa4e: 74 0c je 11fa5c <== NOT EXECUTED fclose(group_fp); 11fa50: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fa53: 50 push %eax <== NOT EXECUTED 11fa54: e8 93 b1 00 00 call 12abec <== NOT EXECUTED 11fa59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 11fa5c: 50 push %eax <== NOT EXECUTED 11fa5d: 50 push %eax <== NOT EXECUTED 11fa5e: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11fa63: 68 54 cf 13 00 push $0x13cf54 <== NOT EXECUTED 11fa68: e8 eb b8 00 00 call 12b358 <== NOT EXECUTED 11fa6d: a3 d4 91 15 00 mov %eax,0x1591d4 <== NOT EXECUTED 11fa72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11fa75: c9 leave <== NOT EXECUTED 11fa76: c3 ret <== NOT EXECUTED 0011fbd8 : return NULL; return &pwent; } void setpwent(void) { 11fbd8: 55 push %ebp <== NOT EXECUTED 11fbd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fbdb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 11fbde: e8 88 fd ff ff call 11f96b <== NOT EXECUTED if (passwd_fp != NULL) 11fbe3: a1 ec 90 15 00 mov 0x1590ec,%eax <== NOT EXECUTED 11fbe8: 85 c0 test %eax,%eax <== NOT EXECUTED 11fbea: 74 0c je 11fbf8 <== NOT EXECUTED fclose(passwd_fp); 11fbec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fbef: 50 push %eax <== NOT EXECUTED 11fbf0: e8 f7 af 00 00 call 12abec <== NOT EXECUTED 11fbf5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 11fbf8: 50 push %eax <== NOT EXECUTED 11fbf9: 50 push %eax <== NOT EXECUTED 11fbfa: 68 3e b2 13 00 push $0x13b23e <== NOT EXECUTED 11fbff: 68 e1 ce 13 00 push $0x13cee1 <== NOT EXECUTED 11fc04: e8 4f b7 00 00 call 12b358 <== NOT EXECUTED 11fc09: a3 ec 90 15 00 mov %eax,0x1590ec <== NOT EXECUTED 11fc0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11fc11: c9 leave <== NOT EXECUTED 11fc12: c3 ret <== NOT EXECUTED 0010a112 : */ int setuid( uid_t uid ) { 10a112: 55 push %ebp <== NOT EXECUTED 10a113: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Uid = uid; 10a115: 8b 15 84 3b 14 00 mov 0x143b84,%edx <== NOT EXECUTED 10a11b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a11e: 66 89 42 2a mov %ax,0x2a(%edx) <== NOT EXECUTED return 0; } 10a122: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a124: c9 leave <== NOT EXECUTED 10a125: c3 ret <== NOT EXECUTED 00107b5f : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 107b5f: 55 push %ebp <== NOT EXECUTED 107b60: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107b62: 56 push %esi <== NOT EXECUTED 107b63: 53 push %ebx <== NOT EXECUTED 107b64: 89 d6 mov %edx,%esi <== NOT EXECUTED 107b66: 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)) { 107b68: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED 107b6f: 74 2e je 107b9f <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107b71: 51 push %ecx <== NOT EXECUTED 107b72: 6a 00 push $0x0 <== NOT EXECUTED 107b74: 6a 00 push $0x0 <== NOT EXECUTED 107b76: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED 107b79: e8 ca 15 00 00 call 109148 <== NOT EXECUTED i = iproc (c, tty); 107b7e: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107b81: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b83: e8 c8 fe ff ff call 107a50 <== NOT EXECUTED 107b88: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_semaphore_release (tty->osem); 107b8a: 5a pop %edx <== NOT EXECUTED 107b8b: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 107b8e: e8 9d 16 00 00 call 109230 <== NOT EXECUTED 107b93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 107b96: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107b98: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107b9b: 5b pop %ebx <== NOT EXECUTED 107b9c: 5e pop %esi <== NOT EXECUTED 107b9d: c9 leave <== NOT EXECUTED 107b9e: c3 ret <== 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); 107b9f: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } return i; } 107ba2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107ba5: 5b pop %ebx <== NOT EXECUTED 107ba6: 5e pop %esi <== NOT EXECUTED 107ba7: 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); 107ba8: e9 a3 fe ff ff jmp 107a50 <== NOT EXECUTED 0011d571 : #if !defined(RTEMS_POSIX_API) unsigned int sleep( unsigned int seconds ) { 11d571: 55 push %ebp <== NOT EXECUTED 11d572: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11d574: 53 push %ebx <== NOT EXECUTED 11d575: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11d578: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_status_code status; rtems_interval ticks_per_second; rtems_interval ticks; status = rtems_clock_get( 11d57b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11d57e: 50 push %eax <== NOT EXECUTED 11d57f: 6a 03 push $0x3 <== NOT EXECUTED 11d581: e8 92 e7 fe ff call 10bd18 <== NOT EXECUTED &ticks_per_second ); ticks = seconds * ticks_per_second; status = rtems_task_wake_after( ticks ); 11d586: 0f af 5d f8 imul -0x8(%ebp),%ebx <== NOT EXECUTED 11d58a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11d58d: e8 6a f5 fe ff call 10cafc <== NOT EXECUTED * Returns the "unslept" amount of time. In RTEMS signals are not * interruptable, so tasks really sleep all of the requested time. */ return 0; } 11d592: 31 c0 xor %eax,%eax <== NOT EXECUTED 11d594: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11d597: c9 leave <== NOT EXECUTED 11d598: c3 ret <== NOT EXECUTED 0010b38c : int _STAT_NAME( const char *path, struct stat *buf ) { 10b38c: 55 push %ebp <== NOT EXECUTED 10b38d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b38f: 57 push %edi <== NOT EXECUTED 10b390: 56 push %esi <== NOT EXECUTED 10b391: 53 push %ebx <== NOT EXECUTED 10b392: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 10b395: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10b399: 75 0d jne 10b3a8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 10b39b: e8 00 f7 01 00 call 12aaa0 <__errno> <== NOT EXECUTED 10b3a0: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10b3a6: eb 45 jmp 10b3ed <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 10b3a8: 6a 01 push $0x1 <== NOT EXECUTED 10b3aa: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10b3ad: 56 push %esi <== NOT EXECUTED 10b3ae: 6a 00 push $0x0 <== NOT EXECUTED 10b3b0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b3b3: e8 42 eb ff ff call 109efa <== NOT EXECUTED if ( status != 0 ) 10b3b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3bb: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10b3be: 85 c0 test %eax,%eax <== NOT EXECUTED 10b3c0: 75 5f jne 10b421 <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 10b3c2: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10b3c5: 83 7a 18 00 cmpl $0x0,0x18(%edx) <== NOT EXECUTED 10b3c9: 75 27 jne 10b3f2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10b3cb: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b3ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10b3d0: 74 10 je 10b3e2 <== NOT EXECUTED 10b3d2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b3d5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b3d7: 74 09 je 10b3e2 <== NOT EXECUTED 10b3d9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3dc: 56 push %esi <== NOT EXECUTED 10b3dd: ff d0 call *%eax <== NOT EXECUTED 10b3df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10b3e2: e8 b9 f6 01 00 call 12aaa0 <__errno> <== NOT EXECUTED 10b3e7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10b3ed: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10b3f0: eb 2f jmp 10b421 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 10b3f2: b9 13 00 00 00 mov $0x13,%ecx <== NOT EXECUTED 10b3f7: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10b3fa: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 10b3fc: 50 push %eax <== NOT EXECUTED 10b3fd: 50 push %eax <== NOT EXECUTED 10b3fe: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b401: 56 push %esi <== NOT EXECUTED 10b402: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 10b405: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10b407: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b40a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b40d: 85 c0 test %eax,%eax <== NOT EXECUTED 10b40f: 74 10 je 10b421 <== NOT EXECUTED 10b411: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b414: 85 c0 test %eax,%eax <== NOT EXECUTED 10b416: 74 09 je 10b421 <== NOT EXECUTED 10b418: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b41b: 56 push %esi <== NOT EXECUTED 10b41c: ff d0 call *%eax <== NOT EXECUTED 10b41e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 10b421: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b423: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b426: 5b pop %ebx <== NOT EXECUTED 10b427: 5e pop %esi <== NOT EXECUTED 10b428: 5f pop %edi <== NOT EXECUTED 10b429: c9 leave <== NOT EXECUTED 10b42a: c3 ret <== NOT EXECUTED 0012074c : int symlink( const char *actualpath, const char *sympath ) { 12074c: 55 push %ebp <== NOT EXECUTED 12074d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12074f: 57 push %edi <== NOT EXECUTED 120750: 56 push %esi <== NOT EXECUTED 120751: 53 push %ebx <== NOT EXECUTED 120752: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 120755: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 120758: 8a 03 mov (%ebx),%al <== NOT EXECUTED 12075a: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 12075c: 74 08 je 120766 <== NOT EXECUTED 12075e: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 120760: 74 04 je 120766 <== NOT EXECUTED 120762: 84 c0 test %al,%al <== NOT EXECUTED 120764: 75 19 jne 12077f <== NOT EXECUTED 120766: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 120769: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 12076e: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 120771: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 120776: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 120778: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 12077d: eb 14 jmp 120793 <== NOT EXECUTED 12077f: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 120782: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 120787: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 12078a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12078f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 120791: 31 d2 xor %edx,%edx <== NOT EXECUTED result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 120793: 51 push %ecx <== NOT EXECUTED 120794: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 120797: 50 push %eax <== NOT EXECUTED 120798: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 12079b: 57 push %edi <== NOT EXECUTED 12079c: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 12079f: 50 push %eax <== NOT EXECUTED 1207a0: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1207a3: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( result != 0 ) 1207a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1207a9: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 1207ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1207ae: 75 50 jne 120800 <== NOT EXECUTED return -1; if ( !loc.ops->symlink_h ) { 1207b0: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1207b3: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1207b6: 85 d2 test %edx,%edx <== NOT EXECUTED 1207b8: 75 20 jne 1207da <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1207ba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1207bd: 85 c0 test %eax,%eax <== NOT EXECUTED 1207bf: 74 09 je 1207ca <== NOT EXECUTED 1207c1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1207c4: 57 push %edi <== NOT EXECUTED 1207c5: ff d0 call *%eax <== NOT EXECUTED 1207c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1207ca: e8 d1 a2 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1207cf: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1207d5: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 1207d8: eb 26 jmp 120800 <== NOT EXECUTED } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 1207da: 50 push %eax <== NOT EXECUTED 1207db: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1207de: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1207e1: 57 push %edi <== NOT EXECUTED 1207e2: ff d2 call *%edx <== NOT EXECUTED 1207e4: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1207e6: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1207e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1207ec: 85 c0 test %eax,%eax <== NOT EXECUTED 1207ee: 74 10 je 120800 <== NOT EXECUTED 1207f0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1207f3: 85 c0 test %eax,%eax <== NOT EXECUTED 1207f5: 74 09 je 120800 <== NOT EXECUTED 1207f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1207fa: 57 push %edi <== NOT EXECUTED 1207fb: ff d0 call *%eax <== NOT EXECUTED 1207fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120800: 89 f0 mov %esi,%eax <== NOT EXECUTED 120802: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120805: 5b pop %ebx <== NOT EXECUTED 120806: 5e pop %esi <== NOT EXECUTED 120807: 5f pop %edi <== NOT EXECUTED 120808: c9 leave <== NOT EXECUTED 120809: c3 ret <== NOT EXECUTED 0012080c : #include int tcdrain( int fd ) { 12080c: 55 push %ebp <== NOT EXECUTED 12080d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12080f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_TCDRAIN, 0 ); 120812: 6a 00 push $0x0 <== NOT EXECUTED 120814: 6a 03 push $0x3 <== NOT EXECUTED 120816: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120819: e8 56 f5 ff ff call 11fd74 <== NOT EXECUTED } 12081e: c9 leave <== NOT EXECUTED 12081f: c3 ret <== NOT EXECUTED 0011228c : int tcgetattr( int fd, struct termios *tp ) { 11228c: 55 push %ebp <== NOT EXECUTED 11228d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11228f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 112292: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112295: 6a 01 push $0x1 <== NOT EXECUTED 112297: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11229a: e8 45 2a 00 00 call 114ce4 <== NOT EXECUTED } 11229f: c9 leave <== NOT EXECUTED 1122a0: c3 ret <== NOT EXECUTED 001122a4 : int tcsetattr( int fd, int opt, struct termios *tp ) { 1122a4: 55 push %ebp <== NOT EXECUTED 1122a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1122a7: 56 push %esi <== NOT EXECUTED 1122a8: 53 push %ebx <== NOT EXECUTED 1122a9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1122ac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1122af: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED switch (opt) { 1122b2: 85 c0 test %eax,%eax <== NOT EXECUTED 1122b4: 74 22 je 1122d8 <== NOT EXECUTED 1122b6: 48 dec %eax <== NOT EXECUTED 1122b7: 74 0d je 1122c6 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 1122b9: e8 ea 2f 00 00 call 1152a8 <__errno> <== NOT EXECUTED 1122be: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1122c4: eb 2a jmp 1122f0 <== NOT EXECUTED case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 1122c6: 50 push %eax <== NOT EXECUTED 1122c7: 6a 00 push $0x0 <== NOT EXECUTED 1122c9: 6a 03 push $0x3 <== NOT EXECUTED 1122cb: 53 push %ebx <== NOT EXECUTED 1122cc: e8 13 2a 00 00 call 114ce4 <== NOT EXECUTED 1122d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1122d4: 85 c0 test %eax,%eax <== NOT EXECUTED 1122d6: 78 18 js 1122f0 <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1122d8: 89 75 10 mov %esi,0x10(%ebp) <== NOT EXECUTED 1122db: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) <== NOT EXECUTED 1122e2: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 1122e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1122e8: 5b pop %ebx <== NOT EXECUTED 1122e9: 5e pop %esi <== NOT EXECUTED 1122ea: c9 leave <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1122eb: e9 f4 29 00 00 jmp 114ce4 <== NOT EXECUTED } } 1122f0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1122f3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1122f6: 5b pop %ebx <== NOT EXECUTED 1122f7: 5e pop %esi <== NOT EXECUTED 1122f8: c9 leave <== NOT EXECUTED 1122f9: c3 ret <== NOT EXECUTED 0010704c : #include int termios_baud_to_number( int termios_baud ) { 10704c: 55 push %ebp <== NOT EXECUTED 10704d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10704f: 8b 55 08 mov 0x8(%ebp),%edx <== 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; 107052: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107057: 83 fa 09 cmp $0x9,%edx <== NOT EXECUTED 10705a: 0f 84 d6 00 00 00 je 107136 <== NOT EXECUTED 107060: 7f 65 jg 1070c7 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; 107062: 66 b8 87 00 mov $0x87,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107066: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 107069: 0f 84 c7 00 00 00 je 107136 <== NOT EXECUTED 10706f: 7f 2e jg 10709f <== NOT EXECUTED 107071: b0 32 mov $0x32,%al <== NOT EXECUTED 107073: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 107076: 0f 84 ba 00 00 00 je 107136 <== NOT EXECUTED 10707c: 7f 09 jg 107087 <== NOT EXECUTED 10707e: 30 c0 xor %al,%al <== NOT EXECUTED 107080: 85 d2 test %edx,%edx <== NOT EXECUTED 107082: e9 aa 00 00 00 jmp 107131 <== NOT EXECUTED 107087: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED 10708c: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10708f: 0f 84 a1 00 00 00 je 107136 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; 107095: b0 6e mov $0x6e,%al <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107097: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10709a: e9 92 00 00 00 jmp 107131 <== 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; 10709f: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070a4: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED 1070a7: 0f 84 89 00 00 00 je 107136 <== 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; 1070ad: b0 96 mov $0x96,%al <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070af: 0f 8c 81 00 00 00 jl 107136 <== 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; 1070b5: 66 b8 2c 01 mov $0x12c,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070b9: 83 fa 07 cmp $0x7,%edx <== NOT EXECUTED 1070bc: 74 78 je 107136 <== 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; 1070be: 66 b8 58 02 mov $0x258,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070c2: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 1070c5: eb 6a jmp 107131 <== 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; 1070c7: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070cc: 83 fa 0e cmp $0xe,%edx <== NOT EXECUTED 1070cf: 74 65 je 107136 <== NOT EXECUTED 1070d1: 7f 21 jg 1070f4 <== 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; 1070d3: 66 b8 60 09 mov $0x960,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070d7: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED 1070da: 74 5a je 107136 <== 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; 1070dc: 66 b8 08 07 mov $0x708,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070e0: 7c 54 jl 107136 <== 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; 1070e2: 66 b8 c0 12 mov $0x12c0,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070e6: 83 fa 0c cmp $0xc,%edx <== NOT EXECUTED 1070e9: 74 4b je 107136 <== 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; 1070eb: 66 b8 80 25 mov $0x2580,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070ef: 83 fa 0d cmp $0xd,%edx <== NOT EXECUTED 1070f2: eb 3d jmp 107131 <== 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; 1070f4: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070f9: 81 fa 02 10 00 00 cmp $0x1002,%edx <== NOT EXECUTED 1070ff: 74 35 je 107136 <== NOT EXECUTED 107101: 7f 16 jg 107119 <== 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; 107103: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107108: 83 fa 0f cmp $0xf,%edx <== NOT EXECUTED 10710b: 74 29 je 107136 <== 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; 10710d: 66 b8 00 e1 mov $0xe100,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107111: 81 fa 01 10 00 00 cmp $0x1001,%edx <== NOT EXECUTED 107117: eb 18 jmp 107131 <== 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; 107119: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10711e: 81 fa 03 10 00 00 cmp $0x1003,%edx <== NOT EXECUTED 107124: 74 10 je 107136 <== 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; 107126: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10712b: 81 fa 04 10 00 00 cmp $0x1004,%edx <== NOT EXECUTED 107131: 74 03 je 107136 <== 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; 107133: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED default: baud = -1; break; } return baud; } 107136: c9 leave <== NOT EXECUTED 107137: c3 ret <== NOT EXECUTED 00120974 : */ char *ttyname( int fd ) { 120974: 55 push %ebp <== NOT EXECUTED 120975: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120977: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 12097a: 68 06 04 00 00 push $0x406 <== NOT EXECUTED 12097f: 68 88 3b 14 00 push $0x143b88 <== NOT EXECUTED 120984: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120987: e8 04 ff ff ff call 120890 <== NOT EXECUTED 12098c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12098f: ba 88 3b 14 00 mov $0x143b88,%edx <== NOT EXECUTED 120994: 85 c0 test %eax,%eax <== NOT EXECUTED 120996: 74 02 je 12099a <== NOT EXECUTED 120998: 31 d2 xor %edx,%edx <== NOT EXECUTED return ttyname_buf; return NULL; } 12099a: 89 d0 mov %edx,%eax <== NOT EXECUTED 12099c: c9 leave <== NOT EXECUTED 12099d: c3 ret <== NOT EXECUTED 00120890 : int ttyname_r( int fd, char *name, size_t namesize ) { 120890: 55 push %ebp <== NOT EXECUTED 120891: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120893: 57 push %edi <== NOT EXECUTED 120894: 56 push %esi <== NOT EXECUTED 120895: 53 push %ebx <== NOT EXECUTED 120896: 81 ec d4 00 00 00 sub $0xd4,%esp <== NOT EXECUTED 12089c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED DIR *dp; struct stat dsb; char *rval; /* Must be a terminal. */ if (tcgetattr (fd, &tty) < 0) 12089f: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 1208a2: 50 push %eax <== NOT EXECUTED 1208a3: 53 push %ebx <== NOT EXECUTED 1208a4: e8 77 ff ff ff call 120820 <== NOT EXECUTED 1208a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1208ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1208ae: 78 38 js 1208e8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) 1208b0: 56 push %esi <== NOT EXECUTED 1208b1: 56 push %esi <== NOT EXECUTED 1208b2: 8d 45 84 lea -0x7c(%ebp),%eax <== NOT EXECUTED 1208b5: 50 push %eax <== NOT EXECUTED 1208b6: 53 push %ebx <== NOT EXECUTED 1208b7: e8 d8 e6 ff ff call 11ef94 <== NOT EXECUTED 1208bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1208bf: 85 c0 test %eax,%eax <== NOT EXECUTED 1208c1: 75 25 jne 1208e8 <== NOT EXECUTED 1208c3: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 1208c6: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 1208cb: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 1208d0: 75 16 jne 1208e8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) 1208d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1208d5: 68 2f d0 13 00 push $0x13d02f <== NOT EXECUTED 1208da: e8 bd f9 ff ff call 12029c <== NOT EXECUTED 1208df: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1208e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1208e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1208e6: 75 58 jne 120940 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); 1208e8: e8 b3 a1 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 1208ed: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1208f3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1208f6: eb 74 jmp 12096c <== NOT EXECUTED for (rval = NULL; (dirp = readdir (dp)) != NULL ;) { if (dirp->d_ino != sb.st_ino) 1208f8: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1208fa: 3b 45 8c cmp -0x74(%ebp),%eax <== NOT EXECUTED 1208fd: 75 4d jne 12094c <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 1208ff: 51 push %ecx <== NOT EXECUTED 120900: 51 push %ecx <== NOT EXECUTED 120901: 8d 42 0c lea 0xc(%edx),%eax <== NOT EXECUTED 120904: 50 push %eax <== NOT EXECUTED 120905: 56 push %esi <== NOT EXECUTED 120906: e8 49 e6 00 00 call 12ef54 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 12090b: 58 pop %eax <== NOT EXECUTED 12090c: 5a pop %edx <== NOT EXECUTED 12090d: 57 push %edi <== NOT EXECUTED 12090e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 120911: e8 76 aa fe ff call 10b38c <== NOT EXECUTED 120916: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120919: 85 c0 test %eax,%eax <== NOT EXECUTED 12091b: 75 2f jne 12094c <== NOT EXECUTED 12091d: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 120920: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED 120923: 3b 85 3c ff ff ff cmp -0xc4(%ebp),%eax <== NOT EXECUTED 120929: 75 21 jne 12094c <== NOT EXECUTED 12092b: 3b 95 38 ff ff ff cmp -0xc8(%ebp),%edx <== NOT EXECUTED 120931: 75 19 jne 12094c <== NOT EXECUTED 120933: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 120936: 3b 85 40 ff ff ff cmp -0xc0(%ebp),%eax <== NOT EXECUTED 12093c: 75 0e jne 12094c <== NOT EXECUTED 12093e: eb 1e jmp 12095e <== NOT EXECUTED for (rval = NULL; (dirp = readdir (dp)) != NULL ;) { if (dirp->d_ino != sb.st_ino) continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 120940: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 120943: 83 c6 05 add $0x5,%esi <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 120946: 8d bd 38 ff ff ff lea -0xc8(%ebp),%edi <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) rtems_set_errno_and_return_minus_one(EBADF); for (rval = NULL; (dirp = readdir (dp)) != NULL ;) 12094c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12094f: 53 push %ebx <== NOT EXECUTED 120950: e8 c7 fb ff ff call 12051c <== NOT EXECUTED 120955: 89 c2 mov %eax,%edx <== NOT EXECUTED 120957: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12095a: 85 c0 test %eax,%eax <== NOT EXECUTED 12095c: 75 9a jne 1208f8 <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 12095e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120961: 53 push %ebx <== NOT EXECUTED 120962: e8 01 88 00 00 call 129168 <== NOT EXECUTED 120967: 31 c0 xor %eax,%eax <== NOT EXECUTED 120969: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 12096c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12096f: 5b pop %ebx <== NOT EXECUTED 120970: 5e pop %esi <== NOT EXECUTED 120971: 5f pop %edi <== NOT EXECUTED 120972: c9 leave <== NOT EXECUTED 120973: c3 ret <== NOT EXECUTED 001209a0 : #include mode_t umask( mode_t cmask ) { 1209a0: 55 push %ebp <== NOT EXECUTED 1209a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED mode_t old_mask; old_mask = rtems_filesystem_umask; 1209a3: 8b 15 84 3b 14 00 mov 0x143b84,%edx <== NOT EXECUTED 1209a9: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED rtems_filesystem_umask = cmask; 1209ac: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1209af: 89 4a 24 mov %ecx,0x24(%edx) <== NOT EXECUTED return old_mask; } 1209b2: c9 leave <== NOT EXECUTED 1209b3: c3 ret <== NOT EXECUTED 0010cd4c : #include int unlink( const char *path ) { 10cd4c: 55 push %ebp <== NOT EXECUTED 10cd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4f: 56 push %esi <== NOT EXECUTED 10cd50: 53 push %ebx <== NOT EXECUTED 10cd51: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node to be unlinked. */ result = rtems_filesystem_evaluate_path( path, 0, &loc, false ); 10cd54: 6a 00 push $0x0 <== NOT EXECUTED 10cd56: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 10cd59: 53 push %ebx <== NOT EXECUTED 10cd5a: 6a 00 push $0x0 <== NOT EXECUTED 10cd5c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cd5f: e8 96 d1 ff ff call 109efa <== NOT EXECUTED if ( result != 0 ) 10cd64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd67: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd69: 0f 85 d9 00 00 00 jne 10ce48 <== NOT EXECUTED return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 10cd6f: 50 push %eax <== NOT EXECUTED 10cd70: 50 push %eax <== NOT EXECUTED 10cd71: 53 push %ebx <== NOT EXECUTED 10cd72: 6a 02 push $0x2 <== NOT EXECUTED 10cd74: e8 0b d1 ff ff call 109e84 <== NOT EXECUTED if (result != 0 && errno != ENOTSUP) { 10cd79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd7c: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd7e: 74 31 je 10cdb1 <== NOT EXECUTED 10cd80: e8 1b dd 01 00 call 12aaa0 <__errno> <== NOT EXECUTED 10cd85: 81 38 86 00 00 00 cmpl $0x86,(%eax) <== NOT EXECUTED 10cd8b: 74 24 je 10cdb1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10cd8d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cd90: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd92: 0f 84 b0 00 00 00 je 10ce48 <== NOT EXECUTED 10cd98: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10cd9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd9d: 0f 84 a5 00 00 00 je 10ce48 <== NOT EXECUTED 10cda3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cda6: 53 push %ebx <== NOT EXECUTED 10cda7: ff d0 call *%eax <== NOT EXECUTED 10cda9: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10cdac: e9 92 00 00 00 jmp 10ce43 <== NOT EXECUTED return -1; } if ( !loc.ops->node_type_h ) { 10cdb1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cdb4: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 10cdb7: 85 d2 test %edx,%edx <== NOT EXECUTED 10cdb9: 75 12 jne 10cdcd <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10cdbb: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10cdbe: 85 d2 test %edx,%edx <== NOT EXECUTED 10cdc0: 74 55 je 10ce17 <== NOT EXECUTED 10cdc2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cdc5: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10cdc8: 50 push %eax <== NOT EXECUTED 10cdc9: ff d2 call *%edx <== NOT EXECUTED 10cdcb: eb 47 jmp 10ce14 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10cdcd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cdd0: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10cdd3: 56 push %esi <== NOT EXECUTED 10cdd4: ff d2 call *%edx <== NOT EXECUTED 10cdd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cdd9: 48 dec %eax <== NOT EXECUTED 10cdda: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cddd: 75 21 jne 10ce00 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10cddf: 85 c0 test %eax,%eax <== NOT EXECUTED 10cde1: 74 10 je 10cdf3 <== NOT EXECUTED 10cde3: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10cde6: 85 c0 test %eax,%eax <== NOT EXECUTED 10cde8: 74 09 je 10cdf3 <== NOT EXECUTED 10cdea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cded: 56 push %esi <== NOT EXECUTED 10cdee: ff d0 call *%eax <== NOT EXECUTED 10cdf0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 10cdf3: e8 a8 dc 01 00 call 12aaa0 <__errno> <== NOT EXECUTED 10cdf8: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10cdfe: eb 48 jmp 10ce48 <== NOT EXECUTED } if ( !loc.ops->unlink_h ) { 10ce00: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 10ce03: 85 d2 test %edx,%edx <== NOT EXECUTED 10ce05: 75 1d jne 10ce24 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10ce07: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10ce0a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce0c: 74 09 je 10ce17 <== NOT EXECUTED 10ce0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce11: 56 push %esi <== NOT EXECUTED 10ce12: ff d0 call *%eax <== NOT EXECUTED 10ce14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10ce17: e8 84 dc 01 00 call 12aaa0 <__errno> <== NOT EXECUTED 10ce1c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ce22: eb 24 jmp 10ce48 <== NOT EXECUTED } result = (*loc.ops->unlink_h)( &loc ); 10ce24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce27: 56 push %esi <== NOT EXECUTED 10ce28: ff d2 call *%edx <== NOT EXECUTED 10ce2a: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10ce2c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ce2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce32: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce34: 74 15 je 10ce4b <== NOT EXECUTED 10ce36: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10ce39: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce3b: 74 0e je 10ce4b <== NOT EXECUTED 10ce3d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce40: 56 push %esi <== NOT EXECUTED 10ce41: ff d0 call *%eax <== NOT EXECUTED 10ce43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce46: eb 03 jmp 10ce4b <== NOT EXECUTED 10ce48: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED return result; } 10ce4b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ce4d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ce50: 5b pop %ebx <== NOT EXECUTED 10ce51: 5e pop %esi <== NOT EXECUTED 10ce52: c9 leave <== NOT EXECUTED 10ce53: c3 ret <== NOT EXECUTED 001209ee : */ int unmount( const char *path ) { 1209ee: 55 push %ebp <== NOT EXECUTED 1209ef: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1209f1: 56 push %esi <== NOT EXECUTED 1209f2: 53 push %ebx <== NOT EXECUTED 1209f3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, 0x0, &loc, true ) ) 1209f6: 6a 01 push $0x1 <== NOT EXECUTED 1209f8: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 1209fb: 56 push %esi <== NOT EXECUTED 1209fc: 6a 00 push $0x0 <== NOT EXECUTED 1209fe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120a01: e8 f4 94 fe ff call 109efa <== NOT EXECUTED 120a06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120a09: 85 c0 test %eax,%eax <== NOT EXECUTED 120a0b: 0f 85 11 01 00 00 jne 120b22 <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 120a11: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 120a14: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 120a17: 3b 45 e8 cmp -0x18(%ebp),%eax <== NOT EXECUTED 120a1a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120a1d: 74 24 je 120a43 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120a1f: 85 c0 test %eax,%eax <== NOT EXECUTED 120a21: 74 10 je 120a33 <== NOT EXECUTED 120a23: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120a26: 85 c0 test %eax,%eax <== NOT EXECUTED 120a28: 74 09 je 120a33 <== NOT EXECUTED 120a2a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120a2d: 56 push %esi <== NOT EXECUTED 120a2e: ff d0 call *%eax <== NOT EXECUTED 120a30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 120a33: e8 68 a0 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120a38: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 120a3e: e9 df 00 00 00 jmp 120b22 <== NOT EXECUTED /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 120a43: 85 c0 test %eax,%eax <== NOT EXECUTED 120a45: 74 10 je 120a57 <== NOT EXECUTED 120a47: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120a4a: 85 c0 test %eax,%eax <== NOT EXECUTED 120a4c: 74 09 je 120a57 <== NOT EXECUTED 120a4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120a51: 56 push %esi <== NOT EXECUTED 120a52: ff d0 call *%eax <== NOT EXECUTED 120a54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 120a57: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120a5a: 83 78 28 00 cmpl $0x0,0x28(%eax) <== NOT EXECUTED 120a5e: 74 09 je 120a69 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 120a60: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 120a63: 83 78 2c 00 cmpl $0x0,0x2c(%eax) <== NOT EXECUTED 120a67: 75 10 jne 120a79 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 120a69: e8 32 a0 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120a6e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120a74: e9 a9 00 00 00 jmp 120b22 <== NOT EXECUTED * that made the current node thread based instead * of system based? I thought it was but it doesn't * look like it in this version. */ if ( rtems_filesystem_current.mt_entry == mt_entry ) 120a79: a1 84 3b 14 00 mov 0x143b84,%eax <== NOT EXECUTED 120a7e: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 120a81: 74 1f je 120aa2 <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 120a83: 8b 15 24 9b 15 00 mov 0x159b24,%edx <== NOT EXECUTED 120a89: eb 0a jmp 120a95 <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 120a8b: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 120a8e: 3b 43 24 cmp 0x24(%ebx),%eax <== NOT EXECUTED 120a91: 74 0f je 120aa2 <== NOT EXECUTED * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 120a93: 8b 12 mov (%edx),%edx <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 120a95: 81 fa 28 9b 15 00 cmp $0x159b28,%edx <== NOT EXECUTED 120a9b: 75 ee jne 120a8b <== NOT EXECUTED 120a9d: e9 8a 00 00 00 jmp 120b2c <== NOT EXECUTED * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) rtems_set_errno_and_return_minus_one( EBUSY ); 120aa2: e8 f9 9f 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120aa7: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 120aad: eb 73 jmp 120b22 <== NOT EXECUTED * Allow the file system being unmounted on to do its cleanup. * If it fails it will set the errno to the approprate value * and the fileystem will not be modified. */ if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 ) 120aaf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ab2: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120ab5: 53 push %ebx <== NOT EXECUTED 120ab6: ff 50 28 call *0x28(%eax) <== NOT EXECUTED 120ab9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120abc: 85 c0 test %eax,%eax <== NOT EXECUTED 120abe: 75 62 jne 120b22 <== NOT EXECUTED * NOTE: Fatal error is called in a case which should never happen * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ 120ac0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ac3: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 120ac6: 53 push %ebx <== NOT EXECUTED 120ac7: ff 50 2c call *0x2c(%eax) <== NOT EXECUTED 120aca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120acd: 85 c0 test %eax,%eax <== NOT EXECUTED 120acf: 74 1b je 120aec <== NOT EXECUTED if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 120ad1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ad4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120ad7: 53 push %ebx <== NOT EXECUTED 120ad8: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 120adb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ade: 85 c0 test %eax,%eax <== NOT EXECUTED 120ae0: 74 40 je 120b22 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 120ae2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ae5: 6a 00 push $0x0 <== NOT EXECUTED 120ae7: e8 88 d3 fe ff call 10de74 <== NOT EXECUTED 120aec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120aef: 53 push %ebx <== NOT EXECUTED 120af0: e8 63 d6 fe ff call 10e158 <_Chain_Extract> <== NOT EXECUTED /* * Free the memory node that was allocated in mount * Free the memory associated with the extracted mount table entry. */ rtems_filesystem_freenode( fs_mount_loc ); 120af5: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120af8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120afb: 85 c0 test %eax,%eax <== NOT EXECUTED 120afd: 74 13 je 120b12 <== NOT EXECUTED 120aff: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 120b02: 85 d2 test %edx,%edx <== NOT EXECUTED 120b04: 74 0c je 120b12 <== NOT EXECUTED 120b06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b09: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 120b0c: 50 push %eax <== NOT EXECUTED 120b0d: ff d2 call *%edx <== NOT EXECUTED 120b0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( mt_entry ); 120b12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b15: 53 push %ebx <== NOT EXECUTED 120b16: e8 01 95 fe ff call 10a01c <== NOT EXECUTED 120b1b: 31 c0 xor %eax,%eax <== NOT EXECUTED 120b1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b20: eb 03 jmp 120b25 <== NOT EXECUTED return 0; 120b22: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 120b25: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120b28: 5b pop %ebx <== NOT EXECUTED 120b29: 5e pop %esi <== NOT EXECUTED 120b2a: c9 leave <== NOT EXECUTED 120b2b: c3 ret <== NOT EXECUTED * Run the file descriptor table to determine if there are any file * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) 120b2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b2f: 53 push %ebx <== NOT EXECUTED 120b30: e8 17 97 fe ff call 10a24c <== NOT EXECUTED 120b35: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b38: 48 dec %eax <== NOT EXECUTED 120b39: 0f 85 70 ff ff ff jne 120aaf <== NOT EXECUTED 120b3f: e9 5e ff ff ff jmp 120aa2 <== NOT EXECUTED 00120b44 : int utime( const char *path, const struct utimbuf *times ) { 120b44: 55 push %ebp <== NOT EXECUTED 120b45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120b47: 57 push %edi <== NOT EXECUTED 120b48: 56 push %esi <== NOT EXECUTED 120b49: 53 push %ebx <== NOT EXECUTED 120b4a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 120b4d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_filesystem_location_info_t temp_loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) ) 120b50: 6a 01 push $0x1 <== NOT EXECUTED 120b52: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 120b55: 56 push %esi <== NOT EXECUTED 120b56: 6a 00 push $0x0 <== NOT EXECUTED 120b58: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120b5b: e8 9a 93 fe ff call 109efa <== NOT EXECUTED 120b60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b63: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 120b66: 85 c0 test %eax,%eax <== NOT EXECUTED 120b68: 75 4f jne 120bb9 <== NOT EXECUTED return -1; if ( !temp_loc.ops->utime_h ){ 120b6a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120b6d: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 120b70: 85 d2 test %edx,%edx <== NOT EXECUTED 120b72: 75 20 jne 120b94 <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 120b74: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120b77: 85 c0 test %eax,%eax <== NOT EXECUTED 120b79: 74 09 je 120b84 <== NOT EXECUTED 120b7b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b7e: 56 push %esi <== NOT EXECUTED 120b7f: ff d0 call *%eax <== NOT EXECUTED 120b81: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 120b84: e8 17 9f 00 00 call 12aaa0 <__errno> <== NOT EXECUTED 120b89: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120b8f: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 120b92: eb 25 jmp 120bb9 <== NOT EXECUTED } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 120b94: 50 push %eax <== NOT EXECUTED 120b95: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 120b98: ff 37 pushl (%edi) <== NOT EXECUTED 120b9a: 56 push %esi <== NOT EXECUTED 120b9b: ff d2 call *%edx <== NOT EXECUTED 120b9d: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 120b9f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120ba2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ba5: 85 c0 test %eax,%eax <== NOT EXECUTED 120ba7: 74 10 je 120bb9 <== NOT EXECUTED 120ba9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120bac: 85 c0 test %eax,%eax <== NOT EXECUTED 120bae: 74 09 je 120bb9 <== NOT EXECUTED 120bb0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120bb3: 56 push %esi <== NOT EXECUTED 120bb4: ff d0 call *%eax <== NOT EXECUTED 120bb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120bb9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120bbb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120bbe: 5b pop %ebx <== NOT EXECUTED 120bbf: 5e pop %esi <== NOT EXECUTED 120bc0: 5f pop %edi <== NOT EXECUTED 120bc1: c9 leave <== NOT EXECUTED 120bc2: c3 ret <== NOT EXECUTED 00106d98 : */ void vprintk( const char *fmt, va_list ap ) { 106d98: 55 push %ebp <== NOT EXECUTED 106d99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d9b: 57 push %edi <== NOT EXECUTED 106d9c: 56 push %esi <== NOT EXECUTED 106d9d: 53 push %ebx <== NOT EXECUTED 106d9e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED 106da1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106da4: e9 6d 02 00 00 jmp 107016 <== NOT EXECUTED base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 106da9: 3c 25 cmp $0x25,%al <== NOT EXECUTED 106dab: 0f 85 54 02 00 00 jne 107005 <== NOT EXECUTED fmt++; 106db1: 47 inc %edi <== NOT EXECUTED if (*fmt == '0' ) { 106db2: c7 45 c8 20 00 00 00 movl $0x20,-0x38(%ebp) <== NOT EXECUTED 106db9: 80 3f 30 cmpb $0x30,(%edi) <== NOT EXECUTED 106dbc: 75 08 jne 106dc6 <== NOT EXECUTED lead = '0'; fmt++; 106dbe: 47 inc %edi <== NOT EXECUTED 106dbf: c7 45 c8 30 00 00 00 movl $0x30,-0x38(%ebp) <== NOT EXECUTED } if (*fmt == '-' ) { 106dc6: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED 106dcd: 80 3f 2d cmpb $0x2d,(%edi) <== NOT EXECUTED 106dd0: 75 08 jne 106dda <== NOT EXECUTED minus = 1; fmt++; 106dd2: 47 inc %edi <== NOT EXECUTED 106dd3: c7 45 cc 01 00 00 00 movl $0x1,-0x34(%ebp) <== NOT EXECUTED 106dda: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED 106de1: eb 0f jmp 106df2 <== NOT EXECUTED } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; 106de3: 6b 55 c4 0a imul $0xa,-0x3c(%ebp),%edx <== NOT EXECUTED width += (*fmt - '0'); 106de7: 0f be c1 movsbl %cl,%eax <== NOT EXECUTED 106dea: 8d 44 02 d0 lea -0x30(%edx,%eax,1),%eax <== NOT EXECUTED 106dee: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED fmt++; 106df1: 47 inc %edi <== NOT EXECUTED } if (*fmt == '-' ) { minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 106df2: 8a 0f mov (%edi),%cl <== NOT EXECUTED 106df4: 8d 41 d0 lea -0x30(%ecx),%eax <== NOT EXECUTED 106df7: 3c 09 cmp $0x9,%al <== NOT EXECUTED 106df9: 76 e8 jbe 106de3 <== NOT EXECUTED width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') { 106dfb: 31 d2 xor %edx,%edx <== NOT EXECUTED 106dfd: 80 f9 6c cmp $0x6c,%cl <== NOT EXECUTED 106e00: 75 08 jne 106e0a <== NOT EXECUTED lflag = 1; c = *++fmt; 106e02: 47 inc %edi <== NOT EXECUTED 106e03: 8a 0f mov (%edi),%cl <== NOT EXECUTED 106e05: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED } switch (c) { 106e0a: 80 f9 64 cmp $0x64,%cl <== NOT EXECUTED 106e0d: 74 71 je 106e80 <== NOT EXECUTED 106e0f: 7f 38 jg 106e49 <== NOT EXECUTED 106e11: 80 f9 4f cmp $0x4f,%cl <== NOT EXECUTED 106e14: 0f 84 32 01 00 00 je 106f4c <== NOT EXECUTED 106e1a: 7f 10 jg 106e2c <== NOT EXECUTED 106e1c: 80 f9 44 cmp $0x44,%cl <== NOT EXECUTED 106e1f: 74 5f je 106e80 <== NOT EXECUTED 106e21: 80 f9 49 cmp $0x49,%cl <== NOT EXECUTED 106e24: 0f 85 17 01 00 00 jne 106f41 <== NOT EXECUTED 106e2a: eb 54 jmp 106e80 <== NOT EXECUTED 106e2c: 80 f9 58 cmp $0x58,%cl <== NOT EXECUTED 106e2f: 0f 84 20 01 00 00 je 106f55 <== NOT EXECUTED 106e35: 80 f9 63 cmp $0x63,%cl <== NOT EXECUTED 106e38: 0f 84 e5 00 00 00 je 106f23 <== NOT EXECUTED 106e3e: 80 f9 55 cmp $0x55,%cl <== NOT EXECUTED 106e41: 0f 85 fa 00 00 00 jne 106f41 <== NOT EXECUTED 106e47: eb 3e jmp 106e87 <== NOT EXECUTED 106e49: 80 f9 70 cmp $0x70,%cl <== NOT EXECUTED 106e4c: 0f 84 03 01 00 00 je 106f55 <== NOT EXECUTED 106e52: 7f 13 jg 106e67 <== NOT EXECUTED 106e54: 80 f9 69 cmp $0x69,%cl <== NOT EXECUTED 106e57: 74 27 je 106e80 <== NOT EXECUTED 106e59: 80 f9 6f cmp $0x6f,%cl <== NOT EXECUTED 106e5c: 0f 85 df 00 00 00 jne 106f41 <== NOT EXECUTED 106e62: e9 e5 00 00 00 jmp 106f4c <== NOT EXECUTED 106e67: 80 f9 75 cmp $0x75,%cl <== NOT EXECUTED 106e6a: 74 1b je 106e87 <== NOT EXECUTED 106e6c: 80 f9 78 cmp $0x78,%cl <== NOT EXECUTED 106e6f: 0f 84 e0 00 00 00 je 106f55 <== NOT EXECUTED 106e75: 80 f9 73 cmp $0x73,%cl <== NOT EXECUTED 106e78: 0f 85 c3 00 00 00 jne 106f41 <== NOT EXECUTED 106e7e: eb 13 jmp 106e93 <== NOT EXECUTED 106e80: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 106e85: eb 02 jmp 106e89 <== NOT EXECUTED 106e87: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e89: be 0a 00 00 00 mov $0xa,%esi <== NOT EXECUTED 106e8e: e9 c9 00 00 00 jmp 106f5c <== NOT EXECUTED case 'p': base = 16; sign = 0; break; case 's': { int i, len; char *s; str = va_arg(ap, char *); 106e93: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106e96: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 106e99: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 106e9c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106e9f: 8b 12 mov (%edx),%edx <== NOT EXECUTED 106ea1: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 106ea4: 31 f6 xor %esi,%esi <== NOT EXECUTED 106ea6: eb 01 jmp 106ea9 <== NOT EXECUTED /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 106ea8: 46 inc %esi <== NOT EXECUTED 106ea9: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 106eac: 80 3c 31 00 cmpb $0x0,(%ecx,%esi,1) <== NOT EXECUTED 106eb0: 75 f6 jne 106ea8 <== NOT EXECUTED ; /* leading spaces */ if ( !minus ) 106eb2: 89 f3 mov %esi,%ebx <== NOT EXECUTED 106eb4: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) <== NOT EXECUTED 106eb8: 74 11 je 106ecb <== NOT EXECUTED 106eba: eb 14 jmp 106ed0 <== NOT EXECUTED for ( i=len ; i <== NOT EXECUTED BSP_output_char(' '); /* no width option */ if (width == 0) { 106ed0: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) <== NOT EXECUTED 106ed4: 75 03 jne 106ed9 <== NOT EXECUTED 106ed6: 89 75 c4 mov %esi,-0x3c(%ebp) <== NOT EXECUTED width = len; } /* output the string */ for ( i=0 ; i <== NOT EXECUTED 106edf: eb 13 jmp 106ef4 <== NOT EXECUTED BSP_output_char(*str); 106ee1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106ee4: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 106ee7: 50 push %eax <== NOT EXECUTED 106ee8: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i <== NOT EXECUTED BSP_output_char(*str); /* trailing spaces */ if ( minus ) 106efd: 89 f3 mov %esi,%ebx <== NOT EXECUTED 106eff: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) <== NOT EXECUTED 106f03: 75 14 jne 106f19 <== NOT EXECUTED 106f05: e9 18 01 00 00 jmp 107022 <== NOT EXECUTED for ( i=len ; i <== NOT EXECUTED 106f1e: e9 ff 00 00 00 jmp 107022 <== NOT EXECUTED BSP_output_char(' '); } break; case 'c': BSP_output_char(va_arg(ap, int)); 106f23: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 106f26: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 106f29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f2c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106f2f: 0f be 01 movsbl (%ecx),%eax <== NOT EXECUTED 106f32: 50 push %eax <== NOT EXECUTED 106f33: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED 106f39: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 106f3c: e9 d1 00 00 00 jmp 107012 <== NOT EXECUTED break; default: BSP_output_char(c); 106f41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f44: 0f be c1 movsbl %cl,%eax <== NOT EXECUTED 106f47: e9 bf 00 00 00 jmp 10700b <== NOT EXECUTED 106f4c: 31 c0 xor %eax,%eax <== NOT EXECUTED 106f4e: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED 106f53: eb 07 jmp 106f5c <== NOT EXECUTED 106f55: 31 c0 xor %eax,%eax <== NOT EXECUTED 106f57: be 10 00 00 00 mov $0x10,%esi <== NOT EXECUTED break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 106f5c: 85 d2 test %edx,%edx <== NOT EXECUTED 106f5e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106f61: 8d 51 04 lea 0x4(%ecx),%edx <== NOT EXECUTED 106f64: 75 03 jne 106f69 <== NOT EXECUTED 106f66: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106f69: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 106f6b: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 106f6e: 48 dec %eax <== NOT EXECUTED 106f6f: 75 1c jne 106f8d <== NOT EXECUTED 106f71: 85 db test %ebx,%ebx <== NOT EXECUTED 106f73: 79 18 jns 106f8d <== NOT EXECUTED BSP_output_char('-'); 106f75: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f78: 6a 2d push $0x2d <== NOT EXECUTED 106f7a: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED num = -num; 106f80: f7 db neg %ebx <== NOT EXECUTED if (maxwidth) maxwidth--; 106f82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f85: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) <== NOT EXECUTED 106f89: 83 55 c4 ff adcl $0xffffffff,-0x3c(%ebp) <== NOT EXECUTED 106f8d: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 106f8f: eb 12 jmp 106fa3 <== NOT EXECUTED } count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); 106f91: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 106f94: 0f af c6 imul %esi,%eax <== NOT EXECUTED 106f97: 28 c3 sub %al,%bl <== NOT EXECUTED 106f99: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1) <== NOT EXECUTED 106f9d: 8b 4d b8 mov -0x48(%ebp),%ecx <== NOT EXECUTED 106fa0: 8b 5d b4 mov -0x4c(%ebp),%ebx <== NOT EXECUTED num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 106fa3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 106fa5: 31 d2 xor %edx,%edx <== NOT EXECUTED 106fa7: f7 f6 div %esi <== NOT EXECUTED 106fa9: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 106fac: 85 c0 test %eax,%eax <== NOT EXECUTED 106fae: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 106fb1: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED 106fb4: 75 db jne 106f91 <== NOT EXECUTED toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; 106fb6: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1) <== NOT EXECUTED for (n=maxwidth ; n > count; n-- ) 106fba: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED BSP_output_char(lead); 106fbd: 0f be 75 c8 movsbl -0x38(%ebp),%esi <== NOT EXECUTED 106fc1: eb 0e jmp 106fd1 <== NOT EXECUTED 106fc3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106fc6: 56 push %esi <== NOT EXECUTED 106fc7: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 106fcd: 4b dec %ebx <== NOT EXECUTED 106fce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106fd1: 3b 5d b8 cmp -0x48(%ebp),%ebx <== NOT EXECUTED 106fd4: 77 ed ja 106fc3 <== NOT EXECUTED 106fd6: 31 db xor %ebx,%ebx <== NOT EXECUTED BSP_output_char(lead); for (n = 0; n < count; n++) { BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 106fd8: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 106fdb: 03 75 b8 add -0x48(%ebp),%esi <== NOT EXECUTED 106fde: eb 1e jmp 106ffe <== NOT EXECUTED 106fe0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106fe3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 106fe5: f7 d0 not %eax <== NOT EXECUTED 106fe7: 0f be 44 30 ec movsbl -0x14(%eax,%esi,1),%eax <== NOT EXECUTED 106fec: 0f be 80 82 67 11 00 movsbl 0x116782(%eax),%eax <== NOT EXECUTED 106ff3: 50 push %eax <== NOT EXECUTED 106ff4: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++) { 106ffa: 43 inc %ebx <== NOT EXECUTED 106ffb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ffe: 3b 5d b8 cmp -0x48(%ebp),%ebx <== NOT EXECUTED 107001: 72 dd jb 106fe0 <== NOT EXECUTED 107003: eb 10 jmp 107015 <== NOT EXECUTED if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 107005: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107008: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 10700b: 50 push %eax <== NOT EXECUTED 10700c: ff 15 fc 86 11 00 call *0x1186fc <== NOT EXECUTED 107012: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107015: 47 inc %edi <== NOT EXECUTED 107016: 8a 07 mov (%edi),%al <== NOT EXECUTED 107018: 84 c0 test %al,%al <== NOT EXECUTED 10701a: 0f 85 89 fd ff ff jne 106da9 <== NOT EXECUTED 107020: eb 08 jmp 10702a <== NOT EXECUTED base, sign, width, lead); } else { BSP_output_char(*fmt); } } } 107022: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 107025: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 107028: eb eb jmp 107015 <== NOT EXECUTED 10702a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10702d: 5b pop %ebx <== NOT EXECUTED 10702e: 5e pop %esi <== NOT EXECUTED 10702f: 5f pop %edi <== NOT EXECUTED 107030: c9 leave <== NOT EXECUTED 107031: c3 ret <== NOT EXECUTED 00114ee0 : ssize_t write( int fd, const void *buffer, size_t count ) { 114ee0: 55 push %ebp <== NOT EXECUTED 114ee1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ee3: 56 push %esi <== NOT EXECUTED 114ee4: 53 push %ebx <== NOT EXECUTED 114ee5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ee8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 114eeb: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 114eee: 3b 05 d8 85 11 00 cmp 0x1185d8,%eax <== NOT EXECUTED 114ef4: 73 11 jae 114f07 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 114ef6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 114ef9: 03 1d a0 c8 11 00 add 0x11c8a0,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 114eff: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 114f02: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 114f05: 75 0d jne 114f14 <== NOT EXECUTED 114f07: e8 a4 97 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114f0c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 114f12: eb 31 jmp 114f45 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 114f14: 85 f6 test %esi,%esi <== NOT EXECUTED 114f16: 74 0b je 114f23 <== NOT EXECUTED rtems_libio_check_count( count ); 114f18: 31 c0 xor %eax,%eax <== NOT EXECUTED 114f1a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114f1c: 74 3c je 114f5a <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 114f1e: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 114f21: 75 0d jne 114f30 <== NOT EXECUTED 114f23: e8 88 97 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114f28: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 114f2e: eb 15 jmp 114f45 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 114f30: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 114f33: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 114f36: 85 c0 test %eax,%eax <== NOT EXECUTED 114f38: 75 10 jne 114f4a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 114f3a: e8 71 97 ff ff call 10e6b0 <__errno> <== NOT EXECUTED 114f3f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 114f45: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114f48: eb 10 jmp 114f5a <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 114f4a: 52 push %edx <== NOT EXECUTED 114f4b: 51 push %ecx <== NOT EXECUTED 114f4c: 56 push %esi <== NOT EXECUTED 114f4d: 53 push %ebx <== NOT EXECUTED 114f4e: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 114f50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114f53: 85 c0 test %eax,%eax <== NOT EXECUTED 114f55: 7e 03 jle 114f5a <== NOT EXECUTED iop->offset += rc; 114f57: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 114f5a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114f5d: 5b pop %ebx <== NOT EXECUTED 114f5e: 5e pop %esi <== NOT EXECUTED 114f5f: c9 leave <== NOT EXECUTED 114f60: c3 ret <== NOT EXECUTED