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 0010c208 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10c208: 55 push %ebp <== NOT EXECUTED 10c209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c20b: 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; 10c20e: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10c211: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED switch( node->type ) { 10c214: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10c216: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10c219: 48 dec %eax <== NOT EXECUTED 10c21a: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10c21d: 77 24 ja 10c243 <== NOT EXECUTED 10c21f: ff 24 85 10 75 11 00 jmp *0x117510(,%eax,4) <== NOT EXECUTED case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10c226: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10c229: eb 15 jmp 10c240 <== NOT EXECUTED break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10c22b: c7 41 04 a4 75 11 00 movl $0x1175a4,0x4(%ecx) <== NOT EXECUTED 10c232: eb 0f jmp 10c243 <== NOT EXECUTED break; case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10c234: c7 41 04 dc 75 11 00 movl $0x1175dc,0x4(%ecx) <== NOT EXECUTED 10c23b: eb 06 jmp 10c243 <== NOT EXECUTED break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10c23d: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10c240: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED break; } return 0; } 10c243: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c245: c9 leave <== NOT EXECUTED 10c246: c3 ret <== NOT EXECUTED 0011e044 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 11e044: 55 push %ebp <== NOT EXECUTED 11e045: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e047: 57 push %edi <== NOT EXECUTED 11e048: 56 push %esi <== NOT EXECUTED 11e049: 53 push %ebx <== NOT EXECUTED 11e04a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11e04d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11e050: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 11e053: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11e056: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 11e058: e8 9f 15 00 00 call 11f5fc <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 11e05d: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED 11e061: 74 15 je 11e078 <== NOT EXECUTED 11e063: 66 85 c0 test %ax,%ax <== NOT EXECUTED 11e066: 74 10 je 11e078 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 11e068: e8 df d3 00 00 call 12b44c <__errno> <== NOT EXECUTED 11e06d: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 11e073: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11e076: eb 20 jmp 11e098 <== NOT EXECUTED #endif jnode->st_uid = owner; 11e078: 66 89 73 3c mov %si,0x3c(%ebx) <== NOT EXECUTED jnode->st_gid = group; 11e07c: 66 89 7b 3e mov %di,0x3e(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 11e080: 50 push %eax <== NOT EXECUTED 11e081: 50 push %eax <== NOT EXECUTED 11e082: 6a 00 push $0x0 <== NOT EXECUTED 11e084: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 11e087: 50 push %eax <== NOT EXECUTED 11e088: e8 07 c0 fe ff call 10a094 <== NOT EXECUTED 11e08d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11e090: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 11e093: 31 c0 xor %eax,%eax <== NOT EXECUTED 11e095: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 11e098: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e09b: 5b pop %ebx <== NOT EXECUTED 11e09c: 5e pop %esi <== NOT EXECUTED 11e09d: 5f pop %edi <== NOT EXECUTED 11e09e: c9 leave <== NOT EXECUTED 11e09f: c3 ret <== NOT EXECUTED 0010e700 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10e700: 55 push %ebp <== NOT EXECUTED 10e701: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e703: 57 push %edi <== NOT EXECUTED 10e704: 56 push %esi <== NOT EXECUTED 10e705: 53 push %ebx <== NOT EXECUTED 10e706: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e709: 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 ) 10e70c: 31 ff xor %edi,%edi <== NOT EXECUTED 10e70e: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10e712: 74 05 je 10e719 <== NOT EXECUTED parent = parent_loc->node_access; 10e714: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e717: 8b 38 mov (%eax),%edi <== NOT EXECUTED /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 10e719: 50 push %eax <== NOT EXECUTED 10e71a: 50 push %eax <== NOT EXECUTED 10e71b: 6a 60 push $0x60 <== NOT EXECUTED 10e71d: 6a 01 push $0x1 <== NOT EXECUTED 10e71f: e8 3c e5 ff ff call 10cc60 <== NOT EXECUTED 10e724: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !node ) 10e726: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e729: 85 c0 test %eax,%eax <== NOT EXECUTED 10e72b: 0f 84 00 01 00 00 je 10e831 <== NOT EXECUTED /* * Fill in the basic information */ node->st_nlink = 1; 10e731: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) <== NOT EXECUTED node->type = type; 10e737: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e73a: 89 50 4c mov %edx,0x4c(%eax) <== NOT EXECUTED strncpy( node->name, name, IMFS_NAME_MAX ); 10e73d: 50 push %eax <== NOT EXECUTED 10e73e: 6a 20 push $0x20 <== NOT EXECUTED 10e740: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10e743: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 10e746: 50 push %eax <== NOT EXECUTED 10e747: e8 f4 1b 00 00 call 110340 <== NOT EXECUTED /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 10e74c: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10e751: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10e754: f7 d0 not %eax <== NOT EXECUTED 10e756: 21 c6 and %eax,%esi <== NOT EXECUTED 10e758: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); 10e75b: e8 74 e6 ff ff call 10cdd4 <== NOT EXECUTED 10e760: 66 89 43 3c mov %ax,0x3c(%ebx) <== NOT EXECUTED node->st_gid = getegid(); 10e764: e8 5b e6 ff ff call 10cdc4 <== NOT EXECUTED 10e769: 66 89 43 3e mov %ax,0x3e(%ebx) <== NOT EXECUTED /* * Now set all the times. */ gettimeofday( &tv, 0 ); 10e76d: 5a pop %edx <== NOT EXECUTED 10e76e: 59 pop %ecx <== NOT EXECUTED 10e76f: 6a 00 push $0x0 <== NOT EXECUTED 10e771: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10e774: 50 push %eax <== NOT EXECUTED 10e775: e8 6a e6 ff ff call 10cde4 <== NOT EXECUTED node->stat_atime = (time_t) tv.tv_sec; 10e77a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e77d: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED node->stat_mtime = (time_t) tv.tv_sec; 10e780: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED node->stat_ctime = (time_t) tv.tv_sec; 10e783: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 10e786: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e789: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e78c: 48 dec %eax <== NOT EXECUTED 10e78d: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10e790: 77 62 ja 10e7f4 <== NOT EXECUTED 10e792: ff 24 85 c8 79 11 00 jmp *0x1179c8(,%eax,4) <== NOT EXECUTED 10e799: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10e79c: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e79f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10e7a6: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10e7a9: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 10e7ac: eb 5c jmp 10e80a <== 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; 10e7ae: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10e7b1: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e7b3: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e7b6: eb 52 jmp 10e80a <== NOT EXECUTED break; case IMFS_DEVICE: node->info.device.major = info->device.major; 10e7b8: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10e7bb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e7bd: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED node->info.device.minor = info->device.minor; 10e7c0: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e7c3: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 10e7c6: eb 42 jmp 10e80a <== NOT EXECUTED break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 10e7c8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 10e7cf: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10e7d6: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.file.indirect = 0; 10e7dd: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED node->info.file.doubly_indirect = 0; 10e7e4: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED node->info.file.triply_indirect = 0; 10e7eb: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 10e7f2: eb 16 jmp 10e80a <== NOT EXECUTED break; default: assert(0); 10e7f4: 68 ef 6a 11 00 push $0x116aef <== NOT EXECUTED 10e7f9: 68 e0 79 11 00 push $0x1179e0 <== NOT EXECUTED 10e7fe: 6a 74 push $0x74 <== NOT EXECUTED 10e800: 68 7c 79 11 00 push $0x11797c <== NOT EXECUTED 10e805: e8 6e 7a ff ff call 106278 <__assert_func> <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 10e80a: 85 ff test %edi,%edi <== NOT EXECUTED 10e80c: 74 23 je 10e831 <== NOT EXECUTED 10e80e: 50 push %eax <== NOT EXECUTED 10e80f: 50 push %eax <== NOT EXECUTED 10e810: 53 push %ebx <== NOT EXECUTED 10e811: 8d 47 50 lea 0x50(%edi),%eax <== NOT EXECUTED 10e814: 50 push %eax <== NOT EXECUTED 10e815: e8 a6 b2 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 10e81a: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED fs_info = parent_loc->mt_entry->fs_info; 10e81d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e820: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e823: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED node->st_ino = ++fs_info->ino_count; 10e826: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e828: 40 inc %eax <== NOT EXECUTED 10e829: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e82b: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED 10e82e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return node; } 10e831: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e833: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e836: 5b pop %ebx <== NOT EXECUTED 10e837: 5e pop %esi <== NOT EXECUTED 10e838: 5f pop %edi <== NOT EXECUTED 10e839: c9 leave <== NOT EXECUTED 10e83a: c3 ret <== NOT EXECUTED 001079d9 : * NOTE: Assuming the "/" directory is bad. * Not checking that the starting directory is in an IMFS is bad. */ void IMFS_dump( void ) { 1079d9: 55 push %ebp <== NOT EXECUTED 1079da: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1079dc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED fprintf(stdout, "*************** Dump of Entire IMFS ***************\n" ); 1079df: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 1079e4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1079e7: 68 b0 cb 11 00 push $0x11cbb0 <== NOT EXECUTED 1079ec: e8 fb b1 00 00 call 112bec <== NOT EXECUTED fprintf(stdout, "/\n" ); 1079f1: 58 pop %eax <== NOT EXECUTED 1079f2: 5a pop %edx <== NOT EXECUTED 1079f3: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 1079f8: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1079fb: 68 e5 cb 11 00 push $0x11cbe5 <== NOT EXECUTED 107a00: e8 e7 b1 00 00 call 112bec <== NOT EXECUTED IMFS_dump_directory( rtems_filesystem_root.node_access, 0 ); 107a05: 59 pop %ecx <== NOT EXECUTED 107a06: 58 pop %eax <== NOT EXECUTED 107a07: 6a 00 push $0x0 <== NOT EXECUTED 107a09: a1 b4 0f 12 00 mov 0x120fb4,%eax <== NOT EXECUTED 107a0e: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 107a11: e8 10 ff ff ff call 107926 <== NOT EXECUTED fprintf(stdout, "*************** End of Dump ***************\n" ); 107a16: 58 pop %eax <== NOT EXECUTED 107a17: 5a pop %edx <== NOT EXECUTED 107a18: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 107a1d: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107a20: 68 e8 cb 11 00 push $0x11cbe8 <== NOT EXECUTED 107a25: e8 c2 b1 00 00 call 112bec <== NOT EXECUTED 107a2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107a2d: c9 leave <== NOT EXECUTED 107a2e: c3 ret <== NOT EXECUTED 00107926 : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 107926: 55 push %ebp <== NOT EXECUTED 107927: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107929: 57 push %edi <== NOT EXECUTED 10792a: 56 push %esi <== NOT EXECUTED 10792b: 53 push %ebx <== NOT EXECUTED 10792c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10792f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107932: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 107935: 85 c0 test %eax,%eax <== NOT EXECUTED 107937: 75 0e jne 107947 <== NOT EXECUTED 107939: 68 6c cb 11 00 push $0x11cb6c <== NOT EXECUTED 10793e: 68 54 cc 11 00 push $0x11cc54 <== NOT EXECUTED 107943: 6a 7f push $0x7f <== NOT EXECUTED 107945: eb 13 jmp 10795a <== NOT EXECUTED assert( level >= 0 ); 107947: 85 ff test %edi,%edi <== NOT EXECUTED 107949: 79 19 jns 107964 <== NOT EXECUTED 10794b: 68 7a cb 11 00 push $0x11cb7a <== NOT EXECUTED 107950: 68 54 cc 11 00 push $0x11cc54 <== NOT EXECUTED 107955: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 10795a: 68 d0 ca 11 00 push $0x11cad0 <== NOT EXECUTED 10795f: e8 d8 05 00 00 call 107f3c <__assert_func> <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 107964: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 107968: 74 11 je 10797b <== NOT EXECUTED 10796a: 68 85 cb 11 00 push $0x11cb85 <== NOT EXECUTED 10796f: 68 54 cc 11 00 push $0x11cc54 <== NOT EXECUTED 107974: 68 83 00 00 00 push $0x83 <== NOT EXECUTED 107979: eb df jmp 10795a <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 10797b: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 10797e: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 107981: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 107984: 8d 47 01 lea 0x1(%edi),%eax <== NOT EXECUTED 107987: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10798a: eb 40 jmp 1079cc <== NOT EXECUTED for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; 10798c: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 10798e: 50 push %eax <== NOT EXECUTED 10798f: 50 push %eax <== NOT EXECUTED 107990: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 107995: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107998: 68 ab cb 11 00 push $0x11cbab <== NOT EXECUTED 10799d: e8 4a b2 00 00 call 112bec <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 1079a2: 43 inc %ebx <== NOT EXECUTED 1079a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1079a6: 39 fb cmp %edi,%ebx <== NOT EXECUTED 1079a8: 7e e4 jle 10798e <== NOT EXECUTED fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 1079aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1079ad: 56 push %esi <== NOT EXECUTED 1079ae: e8 73 fe ff ff call 107826 <== NOT EXECUTED if ( the_jnode->type == IMFS_DIRECTORY ) 1079b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1079b6: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 1079ba: 75 0e jne 1079ca <== NOT EXECUTED IMFS_dump_directory( the_jnode, level + 1 ); 1079bc: 50 push %eax <== NOT EXECUTED 1079bd: 50 push %eax <== NOT EXECUTED 1079be: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1079c1: 56 push %esi <== NOT EXECUTED 1079c2: e8 5f ff ff ff call 107926 <== NOT EXECUTED 1079c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 1079ca: 8b 36 mov (%esi),%esi <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 1079cc: 3b 75 f0 cmp -0x10(%ebp),%esi <== NOT EXECUTED 1079cf: 75 bb jne 10798c <== NOT EXECUTED fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 1079d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1079d4: 5b pop %ebx <== NOT EXECUTED 1079d5: 5e pop %esi <== NOT EXECUTED 1079d6: 5f pop %edi <== NOT EXECUTED 1079d7: c9 leave <== NOT EXECUTED 1079d8: c3 ret <== NOT EXECUTED 0010c38f : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10c38f: 55 push %ebp <== NOT EXECUTED 10c390: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c392: 57 push %edi <== NOT EXECUTED 10c393: 56 push %esi <== NOT EXECUTED 10c394: 53 push %ebx <== NOT EXECUTED 10c395: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED 10c398: 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; 10c39b: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10c39d: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) <== NOT EXECUTED 10c3a4: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10c3a9: e9 1d 01 00 00 jmp 10c4cb <== 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 ); 10c3ae: 50 push %eax <== NOT EXECUTED 10c3af: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c3b2: 50 push %eax <== NOT EXECUTED 10c3b3: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10c3b6: 50 push %eax <== NOT EXECUTED 10c3b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c3ba: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c3bd: 50 push %eax <== NOT EXECUTED 10c3be: e8 75 04 00 00 call 10c838 <== NOT EXECUTED 10c3c3: 89 c7 mov %eax,%edi <== NOT EXECUTED i += len; 10c3c5: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c3c8: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10c3cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c3ce: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10c3d1: 0f 84 d0 00 00 00 je 10c4a7 <== 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 ) 10c3d7: 85 ff test %edi,%edi <== NOT EXECUTED 10c3d9: 74 1b je 10c3f6 <== NOT EXECUTED if ( node->type == IMFS_DIRECTORY ) 10c3db: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c3df: 75 15 jne 10c3f6 <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10c3e1: 50 push %eax <== NOT EXECUTED 10c3e2: 50 push %eax <== NOT EXECUTED 10c3e3: 6a 01 push $0x1 <== NOT EXECUTED 10c3e5: 53 push %ebx <== NOT EXECUTED 10c3e6: e8 5c fe ff ff call 10c247 <== NOT EXECUTED 10c3eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c3ee: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3f0: 0f 84 3c 01 00 00 je 10c532 <== NOT EXECUTED */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10c3f6: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED 10c3f9: 01 45 b0 add %eax,-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; 10c3fc: 8b 33 mov (%ebx),%esi <== NOT EXECUTED switch( type ) { 10c3fe: 83 ff 03 cmp $0x3,%edi <== NOT EXECUTED 10c401: 74 34 je 10c437 <== NOT EXECUTED 10c403: 83 ff 04 cmp $0x4,%edi <== NOT EXECUTED 10c406: 0f 84 b2 00 00 00 je 10c4be <== NOT EXECUTED 10c40c: 83 ff 02 cmp $0x2,%edi <== NOT EXECUTED 10c40f: 0f 85 b6 00 00 00 jne 10c4cb <== 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 ) 10c415: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10c41a: 3b 70 14 cmp 0x14(%eax),%esi <== NOT EXECUTED 10c41d: 74 8f je 10c3ae <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10c41f: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10c422: 3b 70 18 cmp 0x18(%eax),%esi <== NOT EXECUTED 10c425: 75 0b jne 10c432 <== 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; 10c427: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c42a: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10c42d: e9 b9 00 00 00 jmp 10c4eb <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 10c432: 8b 76 08 mov 0x8(%esi),%esi <== NOT EXECUTED 10c435: eb 6c jmp 10c4a3 <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10c437: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c43a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c43d: 75 15 jne 10c454 <== NOT EXECUTED IMFS_evaluate_hard_link( pathloc, 0 ); 10c43f: 50 push %eax <== NOT EXECUTED 10c440: 50 push %eax <== NOT EXECUTED 10c441: 6a 00 push $0x0 <== NOT EXECUTED 10c443: 53 push %ebx <== NOT EXECUTED 10c444: e8 4c fe ff ff call 10c295 <== NOT EXECUTED node = pathloc->node_access; 10c449: 8b 33 mov (%ebx),%esi <== NOT EXECUTED if ( !node ) 10c44b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c44e: 85 f6 test %esi,%esi <== NOT EXECUTED 10c450: 75 23 jne 10c475 <== NOT EXECUTED 10c452: eb 27 jmp 10c47b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10c454: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c457: 75 1c jne 10c475 <== NOT EXECUTED result = IMFS_evaluate_sym_link( pathloc, 0 ); 10c459: 50 push %eax <== NOT EXECUTED 10c45a: 50 push %eax <== NOT EXECUTED 10c45b: 6a 00 push $0x0 <== NOT EXECUTED 10c45d: 53 push %ebx <== NOT EXECUTED 10c45e: e8 84 fe ff ff call 10c2e7 <== NOT EXECUTED 10c463: 89 c6 mov %eax,%esi <== NOT EXECUTED node = pathloc->node_access; 10c465: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( result == -1 ) 10c467: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c46a: 83 fe ff cmp $0xffffffff,%esi <== NOT EXECUTED 10c46d: 0f 84 cd 00 00 00 je 10c540 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10c473: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c475: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c479: 74 10 je 10c48b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c47b: e8 38 2c 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c480: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10c486: e9 b2 00 00 00 jmp 10c53d <== 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 ) { 10c48b: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10c48e: 85 c0 test %eax,%eax <== NOT EXECUTED 10c490: 75 53 jne 10c4e5 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c492: 50 push %eax <== NOT EXECUTED 10c493: 50 push %eax <== NOT EXECUTED 10c494: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10c497: 50 push %eax <== NOT EXECUTED 10c498: 56 push %esi <== NOT EXECUTED 10c499: e8 0e 03 00 00 call 10c7ac <== NOT EXECUTED 10c49e: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !node ) 10c4a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4a3: 85 f6 test %esi,%esi <== NOT EXECUTED 10c4a5: 75 10 jne 10c4b7 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10c4a7: e8 0c 2c 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c4ac: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10c4b2: e9 86 00 00 00 jmp 10c53d <== NOT EXECUTED /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10c4b7: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 10c4b9: e9 f0 fe ff ff jmp 10c3ae <== NOT EXECUTED case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c4be: e8 f5 2b 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c4c3: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10c4c9: eb 72 jmp 10c53d <== NOT EXECUTED /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10c4cb: 85 ff test %edi,%edi <== NOT EXECUTED 10c4cd: 74 09 je 10c4d8 <== NOT EXECUTED 10c4cf: 83 ff 04 cmp $0x4,%edi <== NOT EXECUTED 10c4d2: 0f 85 d6 fe ff ff jne 10c3ae <== 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 ) { 10c4d8: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c4dc: 75 3b jne 10c519 <== NOT EXECUTED if ( node->info.directory.mt_fs != NULL ) { 10c4de: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10c4e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4e3: 74 34 je 10c519 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10c4e5: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c4e8: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10c4eb: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c4f0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c4f2: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c4f5: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c4f7: 89 df mov %ebx,%edi <== NOT EXECUTED 10c4f9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10c4fb: 50 push %eax <== NOT EXECUTED 10c4fc: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10c4ff: 53 push %ebx <== NOT EXECUTED 10c500: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c503: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c506: 29 45 b0 sub %eax,-0x50(%ebp) <== NOT EXECUTED 10c509: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c50c: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c50f: 50 push %eax <== NOT EXECUTED 10c510: ff 12 call *(%edx) <== NOT EXECUTED 10c512: 89 c6 mov %eax,%esi <== NOT EXECUTED 10c514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c517: eb 27 jmp 10c540 <== NOT EXECUTED } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10c519: 53 push %ebx <== NOT EXECUTED 10c51a: e8 e9 fc ff ff call 10c208 <== NOT EXECUTED 10c51f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10c521: 57 push %edi <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10c522: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c525: 53 push %ebx <== NOT EXECUTED 10c526: e8 1c fd ff ff call 10c247 <== NOT EXECUTED 10c52b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c52e: 85 c0 test %eax,%eax <== NOT EXECUTED 10c530: 75 0e jne 10c540 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10c532: e8 81 2b 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c537: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c53d: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED return result; } 10c540: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c542: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c545: 5b pop %ebx <== NOT EXECUTED 10c546: 5e pop %esi <== NOT EXECUTED 10c547: 5f pop %edi <== NOT EXECUTED 10c548: c9 leave <== NOT EXECUTED 10c549: c3 ret <== NOT EXECUTED 0010c5d1 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10c5d1: 55 push %ebp <== NOT EXECUTED 10c5d2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5d4: 57 push %edi <== NOT EXECUTED 10c5d5: 56 push %esi <== NOT EXECUTED 10c5d6: 53 push %ebx <== NOT EXECUTED 10c5d7: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED 10c5da: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10c5dd: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10c5df: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) <== NOT EXECUTED * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10c5e6: 50 push %eax <== NOT EXECUTED 10c5e7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c5ea: 50 push %eax <== NOT EXECUTED 10c5eb: 8d 55 bf lea -0x41(%ebp),%edx <== NOT EXECUTED 10c5ee: 52 push %edx <== NOT EXECUTED 10c5ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c5f2: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c5f5: 50 push %eax <== NOT EXECUTED 10c5f6: e8 3d 02 00 00 call 10c838 <== NOT EXECUTED 10c5fb: 89 c7 mov %eax,%edi <== NOT EXECUTED i += len; 10c5fd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c600: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10c603: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c606: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10c609: 0f 84 40 01 00 00 je 10c74f <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10c60f: 85 ff test %edi,%edi <== NOT EXECUTED 10c611: 74 1b je 10c62e <== NOT EXECUTED if ( node->type == IMFS_DIRECTORY ) 10c613: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10c617: 75 15 jne 10c62e <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10c619: 50 push %eax <== NOT EXECUTED 10c61a: 50 push %eax <== NOT EXECUTED 10c61b: 6a 01 push $0x1 <== NOT EXECUTED 10c61d: 53 push %ebx <== NOT EXECUTED 10c61e: e8 24 fc ff ff call 10c247 <== NOT EXECUTED 10c623: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c626: 85 c0 test %eax,%eax <== NOT EXECUTED 10c628: 0f 84 63 01 00 00 je 10c791 <== NOT EXECUTED */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10c62e: 8b 55 ac mov -0x54(%ebp),%edx <== NOT EXECUTED 10c631: 01 55 b0 add %edx,-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; 10c634: 8b 33 mov (%ebx),%esi <== NOT EXECUTED switch( type ) { 10c636: 83 ff 02 cmp $0x2,%edi <== NOT EXECUTED 10c639: 74 1b je 10c656 <== NOT EXECUTED 10c63b: 77 0a ja 10c647 <== NOT EXECUTED 10c63d: 85 ff test %edi,%edi <== NOT EXECUTED 10c63f: 0f 84 cf 00 00 00 je 10c714 <== NOT EXECUTED 10c645: eb 9f jmp 10c5e6 <== NOT EXECUTED 10c647: 83 ff 03 cmp $0x3,%edi <== NOT EXECUTED 10c64a: 74 34 je 10c680 <== NOT EXECUTED 10c64c: 83 ff 04 cmp $0x4,%edi <== NOT EXECUTED 10c64f: 75 95 jne 10c5e6 <== NOT EXECUTED 10c651: e9 cb 00 00 00 jmp 10c721 <== 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 ) 10c656: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10c65b: 3b 70 14 cmp 0x14(%eax),%esi <== NOT EXECUTED 10c65e: 74 86 je 10c5e6 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10c660: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10c663: 3b 70 18 cmp 0x18(%eax),%esi <== NOT EXECUTED 10c666: 75 08 jne 10c670 <== NOT EXECUTED if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10c668: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c66b: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10c66e: eb 56 jmp 10c6c6 <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10c670: 8b 76 08 mov 0x8(%esi),%esi <== NOT EXECUTED 10c673: 85 f6 test %esi,%esi <== NOT EXECUTED 10c675: 0f 85 92 00 00 00 jne 10c70d <== NOT EXECUTED 10c67b: e9 cf 00 00 00 jmp 10c74f <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10c680: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c683: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c686: 74 05 je 10c68d <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10c688: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c68b: 75 18 jne 10c6a5 <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); 10c68d: 57 push %edi <== NOT EXECUTED 10c68e: 57 push %edi <== NOT EXECUTED 10c68f: 6a 00 push $0x0 <== NOT EXECUTED 10c691: 53 push %ebx <== NOT EXECUTED 10c692: e8 b3 fe ff ff call 10c54a <== NOT EXECUTED 10c697: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result == -1 ) 10c699: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c69c: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c69f: 0f 84 fa 00 00 00 je 10c79f <== NOT EXECUTED return -1; } node = pathloc->node_access; 10c6a5: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !node ) 10c6a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c6a9: 0f 84 c4 00 00 00 je 10c773 <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c6af: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10c6b3: 0f 85 ba 00 00 00 jne 10c773 <== 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 ) { 10c6b9: 8b 50 5c mov 0x5c(%eax),%edx <== NOT EXECUTED 10c6bc: 85 d2 test %edx,%edx <== NOT EXECUTED 10c6be: 74 38 je 10c6f8 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10c6c0: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10c6c3: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED 10c6c6: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c6cb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10c6cd: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10c6d0: b1 04 mov $0x4,%cl <== NOT EXECUTED 10c6d2: 89 df mov %ebx,%edi <== NOT EXECUTED 10c6d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10c6d6: 56 push %esi <== NOT EXECUTED 10c6d7: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10c6da: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c6dd: 53 push %ebx <== NOT EXECUTED 10c6de: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c6e1: 29 45 b0 sub %eax,-0x50(%ebp) <== NOT EXECUTED 10c6e4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c6e7: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c6ea: 50 push %eax <== NOT EXECUTED 10c6eb: ff 52 04 call *0x4(%edx) <== NOT EXECUTED 10c6ee: 89 c6 mov %eax,%esi <== NOT EXECUTED 10c6f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6f3: e9 a7 00 00 00 jmp 10c79f <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c6f8: 51 push %ecx <== NOT EXECUTED 10c6f9: 51 push %ecx <== NOT EXECUTED 10c6fa: 8d 55 bf lea -0x41(%ebp),%edx <== NOT EXECUTED 10c6fd: 52 push %edx <== NOT EXECUTED 10c6fe: 50 push %eax <== NOT EXECUTED 10c6ff: e8 a8 00 00 00 call 10c7ac <== NOT EXECUTED 10c704: 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 ) 10c706: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c709: 85 c0 test %eax,%eax <== NOT EXECUTED 10c70b: 74 21 je 10c72e <== NOT EXECUTED done = true; else pathloc->node_access = node; 10c70d: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 10c70f: e9 d2 fe ff ff jmp 10c5e6 <== NOT EXECUTED break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10c714: e8 9f 29 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c719: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10c71f: eb 7b jmp 10c79c <== NOT EXECUTED break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c721: e8 92 29 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c726: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10c72c: eb 6e jmp 10c79c <== NOT EXECUTED case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10c72e: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED 10c731: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 10c734: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 10c737: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c73a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c73c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c73f: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10c742: eb 18 jmp 10c75c <== 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++) { 10c744: 40 inc %eax <== NOT EXECUTED if ( !IMFS_is_separator( path[ i ] ) ) 10c745: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10c748: 74 12 je 10c75c <== NOT EXECUTED 10c74a: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10c74d: 74 0d je 10c75c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10c74f: e8 64 29 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c754: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10c75a: eb 40 jmp 10c79c <== 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++) { 10c75c: 8a 10 mov (%eax),%dl <== NOT EXECUTED 10c75e: 84 d2 test %dl,%dl <== NOT EXECUTED 10c760: 75 e2 jne 10c744 <== NOT EXECUTED /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10c762: 53 push %ebx <== NOT EXECUTED 10c763: e8 a0 fa ff ff call 10c208 <== NOT EXECUTED 10c768: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10c76a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10c76c: 5a pop %edx <== NOT EXECUTED 10c76d: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10c771: 74 0d je 10c780 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c773: e8 40 29 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c778: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10c77e: eb 1c jmp 10c79c <== NOT EXECUTED /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10c780: 57 push %edi <== NOT EXECUTED 10c781: 57 push %edi <== NOT EXECUTED 10c782: 6a 03 push $0x3 <== NOT EXECUTED 10c784: 53 push %ebx <== NOT EXECUTED 10c785: e8 bd fa ff ff call 10c247 <== NOT EXECUTED 10c78a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c78d: 85 c0 test %eax,%eax <== NOT EXECUTED 10c78f: 75 0e jne 10c79f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10c791: e8 22 29 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c796: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c79c: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED return result; } 10c79f: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c7a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7a4: 5b pop %ebx <== NOT EXECUTED 10c7a5: 5e pop %esi <== NOT EXECUTED 10c7a6: 5f pop %edi <== NOT EXECUTED 10c7a7: c9 leave <== NOT EXECUTED 10c7a8: c3 ret <== NOT EXECUTED 0010c295 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c295: 55 push %ebp <== NOT EXECUTED 10c296: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c298: 53 push %ebx <== NOT EXECUTED 10c299: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c29c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10c29f: 8b 03 mov (%ebx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10c2a1: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED 10c2a5: 74 0d je 10c2b4 <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); 10c2a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2aa: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c2af: e8 b4 d4 ff ff call 109768 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10c2b4: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 10c2b7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED IMFS_Set_handlers( node ); 10c2b9: 53 push %ebx <== NOT EXECUTED 10c2ba: e8 49 ff ff ff call 10c208 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10c2bf: 50 push %eax <== NOT EXECUTED 10c2c0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c2c3: 53 push %ebx <== NOT EXECUTED 10c2c4: e8 7e ff ff ff call 10c247 <== NOT EXECUTED 10c2c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c2cc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c2ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2d0: 75 0e jne 10c2e0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10c2d2: e8 e1 2d 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c2d7: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c2dd: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED return result; } 10c2e0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c2e2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c2e5: c9 leave <== NOT EXECUTED 10c2e6: c3 ret <== NOT EXECUTED 0010c54a : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c54a: 55 push %ebp <== NOT EXECUTED 10c54b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c54d: 57 push %edi <== NOT EXECUTED 10c54e: 56 push %esi <== NOT EXECUTED 10c54f: 53 push %ebx <== NOT EXECUTED 10c550: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c553: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c556: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10c559: 8b 33 mov (%ebx),%esi <== NOT EXECUTED /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10c55b: 8b 15 4c b5 11 00 mov 0x11b54c,%edx <== NOT EXECUTED 10c561: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10c564: 40 inc %eax <== NOT EXECUTED 10c565: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10c569: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED 10c56d: 76 16 jbe 10c585 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 10c56f: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ELOOP ); 10c575: e8 3e 2b 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c57a: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED 10c580: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10c583: eb 42 jmp 10c5c7 <== NOT EXECUTED /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10c585: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c588: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c58b: 75 0b jne 10c598 <== NOT EXECUTED result = IMFS_evaluate_hard_link( node, flags ); 10c58d: 51 push %ecx <== NOT EXECUTED 10c58e: 51 push %ecx <== NOT EXECUTED 10c58f: 57 push %edi <== NOT EXECUTED 10c590: 53 push %ebx <== NOT EXECUTED 10c591: e8 ff fc ff ff call 10c295 <== NOT EXECUTED 10c596: eb 0e jmp 10c5a6 <== NOT EXECUTED else if (jnode->type == IMFS_SYM_LINK ) 10c598: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10c59b: 75 12 jne 10c5af <== NOT EXECUTED result = IMFS_evaluate_sym_link( node, flags ); 10c59d: 52 push %edx <== NOT EXECUTED 10c59e: 52 push %edx <== NOT EXECUTED 10c59f: 57 push %edi <== NOT EXECUTED 10c5a0: 53 push %ebx <== NOT EXECUTED 10c5a1: e8 41 fd ff ff call 10c2e7 <== NOT EXECUTED 10c5a6: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c5a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10c5ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10c5ad: 75 0d jne 10c5bc <== NOT EXECUTED 10c5af: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10c5b2: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10c5b5: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c5b8: 76 9f jbe 10c559 <== NOT EXECUTED 10c5ba: 31 d2 xor %edx,%edx <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10c5bc: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10c5c1: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) <== NOT EXECUTED return result; } 10c5c7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c5c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c5cc: 5b pop %ebx <== NOT EXECUTED 10c5cd: 5e pop %esi <== NOT EXECUTED 10c5ce: 5f pop %edi <== NOT EXECUTED 10c5cf: c9 leave <== NOT EXECUTED 10c5d0: c3 ret <== NOT EXECUTED 0010c247 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10c247: 55 push %ebp <== NOT EXECUTED 10c248: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c24a: 57 push %edi <== NOT EXECUTED 10c24b: 56 push %esi <== NOT EXECUTED 10c24c: 53 push %ebx <== NOT EXECUTED 10c24d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c250: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10c253: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c256: 8b 30 mov (%eax),%esi <== NOT EXECUTED #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10c258: e8 77 0b 00 00 call 10cdd4 <== NOT EXECUTED 10c25d: 89 c3 mov %eax,%ebx <== NOT EXECUTED st_gid = getegid(); 10c25f: e8 60 0b 00 00 call 10cdc4 <== NOT EXECUTED * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10c264: 66 3b 5e 3c cmp 0x3c(%esi),%bx <== NOT EXECUTED 10c268: 75 07 jne 10c271 <== NOT EXECUTED flags_to_test <<= 6; 10c26a: 89 fa mov %edi,%edx <== NOT EXECUTED 10c26c: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10c26f: eb 0f jmp 10c280 <== NOT EXECUTED else if ( st_gid == jnode->st_gid ) 10c271: 89 fa mov %edi,%edx <== NOT EXECUTED 10c273: 66 3b 46 3e cmp 0x3e(%esi),%ax <== NOT EXECUTED 10c277: 75 07 jne 10c280 <== NOT EXECUTED flags_to_test <<= 3; 10c279: 8d 14 fd 00 00 00 00 lea 0x0(,%edi,8),%edx <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c280: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c282: 23 46 30 and 0x30(%esi),%eax <== NOT EXECUTED 10c285: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c287: 0f 94 c0 sete %al <== NOT EXECUTED 10c28a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED return 1; return 0; } 10c28d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c290: 5b pop %ebx <== NOT EXECUTED 10c291: 5e pop %esi <== NOT EXECUTED 10c292: 5f pop %edi <== NOT EXECUTED 10c293: c9 leave <== NOT EXECUTED 10c294: c3 ret <== NOT EXECUTED 0010c2e7 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c2e7: 55 push %ebp <== NOT EXECUTED 10c2e8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c2ea: 57 push %edi <== NOT EXECUTED 10c2eb: 56 push %esi <== NOT EXECUTED 10c2ec: 53 push %ebx <== NOT EXECUTED 10c2ed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10c2f0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c2f3: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10c2f5: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10c2f9: 74 0a je 10c305 <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); 10c2fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2fe: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c303: eb 0f jmp 10c314 <== NOT EXECUTED if ( !jnode->Parent ) 10c305: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10c308: 85 c0 test %eax,%eax <== NOT EXECUTED 10c30a: 75 0d jne 10c319 <== NOT EXECUTED rtems_fatal_error_occurred( 0xBAD00000 ); 10c30c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c30f: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10c314: e8 4f d4 ff ff call 109768 <== 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; 10c319: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c31c: 89 02 mov %eax,(%edx) <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 10c31e: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10c321: 8a 00 mov (%eax),%al <== NOT EXECUTED 10c323: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10c325: 74 0a je 10c331 <== NOT EXECUTED 10c327: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10c329: 74 06 je 10c331 <== NOT EXECUTED 10c32b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c32d: 84 c0 test %al,%al <== NOT EXECUTED 10c32f: 75 17 jne 10c348 <== NOT EXECUTED 10c331: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10c336: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10c339: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10c33e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c341: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10c343: 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( 10c348: 51 push %ecx <== NOT EXECUTED 10c349: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c34c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c34f: 03 53 50 add 0x50(%ebx),%edx <== NOT EXECUTED 10c352: 52 push %edx <== NOT EXECUTED 10c353: e8 37 00 00 00 call 10c38f <== NOT EXECUTED 10c358: 89 c3 mov %eax,%ebx <== NOT EXECUTED &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10c35a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c35d: e8 a6 fe ff ff call 10c208 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10c362: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c365: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c368: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c36b: e8 d7 fe ff ff call 10c247 <== NOT EXECUTED 10c370: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c373: 85 c0 test %eax,%eax <== NOT EXECUTED 10c375: 75 0e jne 10c385 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10c377: e8 3c 2d 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c37c: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c382: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED return result; } 10c385: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c387: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c38a: 5b pop %ebx <== NOT EXECUTED 10c38b: 5e pop %esi <== NOT EXECUTED 10c38c: 5f pop %edi <== NOT EXECUTED 10c38d: c9 leave <== NOT EXECUTED 10c38e: c3 ret <== NOT EXECUTED 0010e83c : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 10e83c: 55 push %ebp <== NOT EXECUTED 10e83d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e83f: 56 push %esi <== NOT EXECUTED 10e840: 53 push %ebx <== NOT EXECUTED 10e841: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e844: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 10e847: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e84a: 8b 30 mov (%eax),%esi <== NOT EXECUTED /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10e84c: e8 83 e5 ff ff call 10cdd4 <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 10e851: 66 3b 46 3c cmp 0x3c(%esi),%ax <== NOT EXECUTED 10e855: 74 05 je 10e85c <== NOT EXECUTED 10e857: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10e85a: 75 08 jne 10e864 <== NOT EXECUTED #endif /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) 10e85c: f7 c3 00 fe ff ff test $0xfffffe00,%ebx <== NOT EXECUTED 10e862: 74 10 je 10e874 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 10e864: e8 4f 08 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10e869: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10e86f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10e872: eb 25 jmp 10e899 <== NOT EXECUTED jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 10e874: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10e877: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED 10e87c: 09 c3 or %eax,%ebx <== NOT EXECUTED 10e87e: 89 5e 30 mov %ebx,0x30(%esi) <== NOT EXECUTED IMFS_update_ctime( jnode ); 10e881: 50 push %eax <== NOT EXECUTED 10e882: 50 push %eax <== NOT EXECUTED 10e883: 6a 00 push $0x0 <== NOT EXECUTED 10e885: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e888: 50 push %eax <== NOT EXECUTED 10e889: e8 56 e5 ff ff call 10cde4 <== NOT EXECUTED 10e88e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e891: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10e894: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e896: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10e899: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e89c: 5b pop %ebx <== NOT EXECUTED 10e89d: 5e pop %esi <== NOT EXECUTED 10e89e: c9 leave <== NOT EXECUTED 10e89f: c3 ret <== NOT EXECUTED 0012974c : int IMFS_fcntl( int cmd, rtems_libio_t *iop ) { 12974c: 55 push %ebp <== NOT EXECUTED 12974d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12974f: 31 c0 xor %eax,%eax <== NOT EXECUTED 129751: c9 leave <== NOT EXECUTED 129752: c3 ret <== NOT EXECUTED 00129754 : #include "imfs.h" int IMFS_fdatasync( rtems_libio_t *iop ) { 129754: 55 push %ebp <== NOT EXECUTED 129755: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 129757: 31 c0 xor %eax,%eax <== NOT EXECUTED 129759: c9 leave <== NOT EXECUTED 12975a: c3 ret <== NOT EXECUTED 0010c7ac : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10c7ac: 55 push %ebp <== NOT EXECUTED 10c7ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7af: 57 push %edi <== NOT EXECUTED 10c7b0: 56 push %esi <== NOT EXECUTED 10c7b1: 53 push %ebx <== NOT EXECUTED 10c7b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c7b5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c7b8: 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 ); 10c7bb: 85 db test %ebx,%ebx <== NOT EXECUTED 10c7bd: 75 16 jne 10c7d5 <== NOT EXECUTED 10c7bf: 68 28 75 11 00 push $0x117528 <== NOT EXECUTED 10c7c4: 68 8c 75 11 00 push $0x11758c <== NOT EXECUTED 10c7c9: 6a 2a push $0x2a <== NOT EXECUTED 10c7cb: 68 32 75 11 00 push $0x117532 <== NOT EXECUTED 10c7d0: e8 a3 9a ff ff call 106278 <__assert_func> <== NOT EXECUTED if ( !name ) 10c7d5: 85 ff test %edi,%edi <== NOT EXECUTED 10c7d7: 74 52 je 10c82b <== NOT EXECUTED /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10c7d9: 51 push %ecx <== NOT EXECUTED 10c7da: 51 push %ecx <== NOT EXECUTED 10c7db: 68 84 75 11 00 push $0x117584 <== NOT EXECUTED 10c7e0: 57 push %edi <== NOT EXECUTED 10c7e1: e8 ce 39 00 00 call 1101b4 <== NOT EXECUTED 10c7e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7e9: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7eb: 74 40 je 10c82d <== NOT EXECUTED return directory; if ( !strcmp( name, dotdotname ) ) 10c7ed: 52 push %edx <== NOT EXECUTED 10c7ee: 52 push %edx <== NOT EXECUTED 10c7ef: 68 86 75 11 00 push $0x117586 <== NOT EXECUTED 10c7f4: 57 push %edi <== NOT EXECUTED 10c7f5: e8 ba 39 00 00 call 1101b4 <== NOT EXECUTED 10c7fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7fd: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7ff: 75 05 jne 10c806 <== NOT EXECUTED return directory->Parent; 10c801: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10c804: eb 27 jmp 10c82d <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10c806: 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 10c809: 83 c3 54 add $0x54,%ebx <== NOT EXECUTED 10c80c: eb 19 jmp 10c827 <== 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 ) ) 10c80e: 50 push %eax <== NOT EXECUTED 10c80f: 50 push %eax <== NOT EXECUTED 10c810: 8d 46 0c lea 0xc(%esi),%eax <== NOT EXECUTED 10c813: 50 push %eax <== NOT EXECUTED 10c814: 57 push %edi <== NOT EXECUTED 10c815: e8 9a 39 00 00 call 1101b4 <== NOT EXECUTED 10c81a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c81d: 85 c0 test %eax,%eax <== NOT EXECUTED 10c81f: 75 04 jne 10c825 <== NOT EXECUTED 10c821: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10c823: eb 08 jmp 10c82d <== 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 ) { 10c825: 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 ); 10c827: 39 de cmp %ebx,%esi <== NOT EXECUTED 10c829: 75 e3 jne 10c80e <== NOT EXECUTED 10c82b: 31 db xor %ebx,%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10c82d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c82f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c832: 5b pop %ebx <== NOT EXECUTED 10c833: 5e pop %esi <== NOT EXECUTED 10c834: 5f pop %edi <== NOT EXECUTED 10c835: c9 leave <== NOT EXECUTED 10c836: c3 ret <== NOT EXECUTED 0011e780 : */ int IMFS_freenodinfo( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 11e780: 55 push %ebp <== NOT EXECUTED 11e781: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11e783: 31 c0 xor %eax,%eax <== NOT EXECUTED 11e785: c9 leave <== NOT EXECUTED 11e786: c3 ret <== NOT EXECUTED 0011e788 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 11e788: 55 push %ebp <== NOT EXECUTED 11e789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e78b: 57 push %edi <== NOT EXECUTED 11e78c: 56 push %esi <== NOT EXECUTED 11e78d: 53 push %ebx <== NOT EXECUTED 11e78e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11e791: 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; 11e794: 8b 58 18 mov 0x18(%eax),%ebx <== NOT EXECUTED loc = temp_mt_entry->mt_fs_root; 11e797: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 11e79a: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 11e79d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11e7a2: 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; 11e7a4: 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 ); 11e7ab: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 11e7ae: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED loc.node_access = (void *)jnode; 11e7b1: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &loc ); 11e7b4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e7b7: 56 push %esi <== NOT EXECUTED 11e7b8: e8 1f fa ff ff call 11e1dc <== NOT EXECUTED if ( jnode->type != IMFS_DIRECTORY ) { 11e7bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e7c0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 11e7c4: 75 08 jne 11e7ce <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 11e7c6: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 11e7c9: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 11e7cc: 75 12 jne 11e7e0 <== NOT EXECUTED result = IMFS_unlink( &loc ); 11e7ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e7d1: 56 push %esi <== NOT EXECUTED 11e7d2: e8 ed b2 fe ff call 109ac4 <== NOT EXECUTED if (result != 0) 11e7d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e7da: 85 c0 test %eax,%eax <== NOT EXECUTED 11e7dc: 75 1d jne 11e7fb <== NOT EXECUTED 11e7de: 89 fb mov %edi,%ebx <== NOT EXECUTED return -1; jnode = next; } if ( jnode != NULL ) { 11e7e0: 85 db test %ebx,%ebx <== NOT EXECUTED 11e7e2: 74 1c je 11e800 <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { 11e7e4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 11e7e8: 75 c4 jne 11e7ae <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 11e7ea: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 11e7ed: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 11e7f0: 74 bc je 11e7ae <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); 11e7f2: 8b 5b 50 mov 0x50(%ebx),%ebx <== NOT EXECUTED } } } while (jnode != NULL); 11e7f5: 85 db test %ebx,%ebx <== NOT EXECUTED 11e7f7: 75 b5 jne 11e7ae <== NOT EXECUTED 11e7f9: eb 05 jmp 11e800 <== NOT EXECUTED 11e7fb: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11e7fe: eb 02 jmp 11e802 <== NOT EXECUTED 11e800: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11e802: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e805: 5b pop %ebx <== NOT EXECUTED 11e806: 5e pop %esi <== NOT EXECUTED 11e807: 5f pop %edi <== NOT EXECUTED 11e808: c9 leave <== NOT EXECUTED 11e809: c3 ret <== NOT EXECUTED 0010c838 : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10c838: 55 push %ebp <== NOT EXECUTED 10c839: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c83b: 56 push %esi <== NOT EXECUTED 10c83c: 53 push %ebx <== NOT EXECUTED 10c83d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c840: 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]; 10c843: 8a 01 mov (%ecx),%al <== NOT EXECUTED 10c845: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c847: eb 10 jmp 10c859 <== NOT EXECUTED while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; 10c849: 88 04 16 mov %al,(%esi,%edx,1) <== NOT EXECUTED if ( i == IMFS_NAME_MAX ) 10c84c: 75 07 jne 10c855 <== NOT EXECUTED 10c84e: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 10c853: eb 77 jmp 10c8cc <== NOT EXECUTED return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10c855: 42 inc %edx <== NOT EXECUTED 10c856: 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) ) { 10c859: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10c85b: 74 0d je 10c86a <== NOT EXECUTED 10c85d: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10c85f: 74 09 je 10c86a <== NOT EXECUTED 10c861: 84 c0 test %al,%al <== NOT EXECUTED 10c863: 74 05 je 10c86a <== NOT EXECUTED 10c865: 83 fa 20 cmp $0x20,%edx <== NOT EXECUTED 10c868: 7e df jle 10c849 <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { 10c86a: 85 d2 test %edx,%edx <== NOT EXECUTED 10c86c: 75 0e jne 10c87c <== NOT EXECUTED token[i] = c; 10c86e: 88 06 mov %al,(%esi) <== NOT EXECUTED if ( token[i] != '\0' ) { 10c870: 31 db xor %ebx,%ebx <== NOT EXECUTED 10c872: 84 c0 test %al,%al <== NOT EXECUTED 10c874: 74 1b je 10c891 <== NOT EXECUTED 10c876: b2 01 mov $0x1,%dl <== NOT EXECUTED 10c878: b3 01 mov $0x1,%bl <== NOT EXECUTED 10c87a: eb 15 jmp 10c891 <== NOT EXECUTED i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10c87c: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED 10c881: 80 7c 16 ff 00 cmpb $0x0,-0x1(%esi,%edx,1) <== NOT EXECUTED 10c886: 74 09 je 10c891 <== NOT EXECUTED token[i] = '\0'; 10c888: c6 04 16 00 movb $0x0,(%esi,%edx,1) <== NOT EXECUTED 10c88c: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10c891: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c894: 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 ) { 10c896: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10c899: 75 31 jne 10c8cc <== NOT EXECUTED if ( strcmp( token, "..") == 0 ) 10c89b: 52 push %edx <== NOT EXECUTED 10c89c: 52 push %edx <== NOT EXECUTED 10c89d: 68 45 71 11 00 push $0x117145 <== NOT EXECUTED 10c8a2: 56 push %esi <== NOT EXECUTED 10c8a3: e8 0c 39 00 00 call 1101b4 <== NOT EXECUTED 10c8a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8ad: 75 04 jne 10c8b3 <== NOT EXECUTED 10c8af: b3 02 mov $0x2,%bl <== NOT EXECUTED 10c8b1: eb 19 jmp 10c8cc <== NOT EXECUTED type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10c8b3: 50 push %eax <== NOT EXECUTED 10c8b4: 50 push %eax <== NOT EXECUTED 10c8b5: 68 46 71 11 00 push $0x117146 <== NOT EXECUTED 10c8ba: 56 push %esi <== NOT EXECUTED 10c8bb: e8 f4 38 00 00 call 1101b4 <== NOT EXECUTED 10c8c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8c5: 75 05 jne 10c8cc <== NOT EXECUTED 10c8c7: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED type = IMFS_CURRENT_DIR; } return type; } 10c8cc: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c8ce: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c8d1: 5b pop %ebx <== NOT EXECUTED 10c8d2: 5e pop %esi <== NOT EXECUTED 10c8d3: c9 leave <== NOT EXECUTED 10c8d4: 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 64 d7 13 00 push $0x13d764 <== NOT EXECUTED 1097c3: 68 d4 d7 13 00 push $0x13d7d4 <== NOT EXECUTED 1097c8: 68 28 b8 13 00 push $0x13b828 <== 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 0010c8d8 : 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 ) { 10c8d8: 55 push %ebp <== NOT EXECUTED 10c8d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8db: 57 push %edi <== NOT EXECUTED 10c8dc: 56 push %esi <== NOT EXECUTED 10c8dd: 53 push %ebx <== NOT EXECUTED 10c8de: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c8e1: 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, 10c8e4: 8b 0d bc 91 11 00 mov 0x1191bc,%ecx <== NOT EXECUTED 10c8ea: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10c8ef: 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); 10c8f1: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c8f3: 74 0d je 10c902 <== NOT EXECUTED bit_mask <<= 1) { 10c8f5: d1 e0 shl %eax <== NOT EXECUTED 10c8f7: 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); 10c8f8: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED 10c8fb: 75 f4 jne 10c8f1 <== NOT EXECUTED 10c8fd: 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) 10c902: a3 34 d4 11 00 mov %eax,0x11d434 <== 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( 10c907: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c90a: 6a 00 push $0x0 <== NOT EXECUTED 10c90c: 68 ed 41 00 00 push $0x41ed <== NOT EXECUTED 10c911: 68 a1 71 11 00 push $0x1171a1 <== NOT EXECUTED 10c916: 6a 01 push $0x1 <== NOT EXECUTED 10c918: 6a 00 push $0x0 <== NOT EXECUTED 10c91a: e8 e1 1d 00 00 call 10e700 <== NOT EXECUTED 10c91f: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10c922: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10c925: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = op_table; 10c928: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c92b: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10c92e: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 10c931: be 4c 79 11 00 mov $0x11794c,%esi <== NOT EXECUTED 10c936: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED 10c93b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10c93d: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10c940: 6a 0c push $0xc <== NOT EXECUTED 10c942: 6a 01 push $0x1 <== NOT EXECUTED 10c944: e8 17 03 00 00 call 10cc60 <== NOT EXECUTED 10c949: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !fs_info ){ 10c94b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c94e: 85 c0 test %eax,%eax <== NOT EXECUTED 10c950: 75 1e jne 10c970 <== NOT EXECUTED free(temp_mt_entry->mt_fs_root.node_access); 10c952: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c955: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10c958: e8 0b 9b ff ff call 106468 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10c95d: e8 56 27 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c962: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10c968: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c96b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c96e: eb 21 jmp 10c991 <== NOT EXECUTED } temp_mt_entry->fs_info = fs_info; 10c970: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10c973: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED fs_info->memfile_handlers = memfile_handlers; 10c979: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c97c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED fs_info->directory_handlers = directory_handlers; 10c97f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10c982: 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; 10c985: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10c988: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) <== NOT EXECUTED 10c98f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c991: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c994: 5b pop %ebx <== NOT EXECUTED 10c995: 5e pop %esi <== NOT EXECUTED 10c996: 5f pop %edi <== NOT EXECUTED 10c997: c9 leave <== NOT EXECUTED 10c998: 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 95 1b 02 00 call 12b44c <__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 ba 47 01 00 call 11e0a0 <== 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 5a 1b 02 00 call 12b44c <__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 001248c4 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 1248c4: 55 push %ebp <== NOT EXECUTED 1248c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1248c7: 53 push %ebx <== NOT EXECUTED 1248c8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1248cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 1248ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1248d0: 75 11 jne 1248e3 <== NOT EXECUTED 1248d2: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 1248d7: 68 88 e2 13 00 push $0x13e288 <== NOT EXECUTED 1248dc: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 1248e1: eb 15 jmp 1248f8 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1248e3: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 1248e7: 74 19 je 124902 <== NOT EXECUTED 1248e9: 68 58 e1 13 00 push $0x13e158 <== NOT EXECUTED 1248ee: 68 88 e2 13 00 push $0x13e288 <== NOT EXECUTED 1248f3: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 1248f8: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 1248fd: e8 c2 53 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 ); 124902: 52 push %edx <== NOT EXECUTED 124903: 6a 01 push $0x1 <== NOT EXECUTED 124905: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124908: 50 push %eax <== NOT EXECUTED 124909: e8 8c fb ff ff call 12449a <== NOT EXECUTED 12490e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( *block_entry_ptr ) 124910: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124913: 31 c0 xor %eax,%eax <== NOT EXECUTED 124915: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 124918: 75 14 jne 12492e <== NOT EXECUTED #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 12491a: e8 59 fb ff ff call 124478 <== NOT EXECUTED 12491f: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !memory ) 124921: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 124926: 85 d2 test %edx,%edx <== NOT EXECUTED 124928: 74 04 je 12492e <== NOT EXECUTED return 1; *block_entry_ptr = memory; 12492a: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 12492c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12492e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124931: c9 leave <== NOT EXECUTED 124932: c3 ret <== NOT EXECUTED 00124933 : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 124933: 55 push %ebp <== NOT EXECUTED 124934: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124936: 57 push %edi <== NOT EXECUTED 124937: 56 push %esi <== NOT EXECUTED 124938: 53 push %ebx <== NOT EXECUTED 124939: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12493c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12493f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124942: 85 ff test %edi,%edi <== NOT EXECUTED 124944: 75 11 jne 124957 <== NOT EXECUTED 124946: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 12494b: 68 a0 e2 13 00 push $0x13e2a0 <== NOT EXECUTED 124950: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 124955: eb 15 jmp 12496c <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 124957: 83 7f 4c 05 cmpl $0x5,0x4c(%edi) <== NOT EXECUTED 12495b: 74 19 je 124976 <== NOT EXECUTED 12495d: 68 58 e1 13 00 push $0x13e158 <== NOT EXECUTED 124962: 68 a0 e2 13 00 push $0x13e2a0 <== NOT EXECUTED 124967: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 12496c: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 124971: e8 4e 53 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 ) 124976: 8b 0d 70 7a 14 00 mov 0x147a70,%ecx <== NOT EXECUTED 12497c: 89 ca mov %ecx,%edx <== NOT EXECUTED 12497e: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 124981: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 124984: 0f af c2 imul %edx,%eax <== NOT EXECUTED 124987: 40 inc %eax <== NOT EXECUTED 124988: 0f af c2 imul %edx,%eax <== NOT EXECUTED 12498b: 48 dec %eax <== NOT EXECUTED 12498c: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 12498f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 124991: 72 0d jb 1249a0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 124993: e8 b4 6a 00 00 call 12b44c <__errno> <== NOT EXECUTED 124998: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12499e: eb 4c jmp 1249ec <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 1249a0: 8b 5f 50 mov 0x50(%edi),%ebx <== NOT EXECUTED 1249a3: 31 d2 xor %edx,%edx <== NOT EXECUTED 1249a5: 39 de cmp %ebx,%esi <== NOT EXECUTED 1249a7: 7e 53 jle 1249fc <== NOT EXECUTED /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 1249a9: 89 f0 mov %esi,%eax <== NOT EXECUTED 1249ab: 99 cltd <== NOT EXECUTED 1249ac: f7 f9 idiv %ecx <== NOT EXECUTED 1249ae: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 1249b1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1249b3: 99 cltd <== NOT EXECUTED 1249b4: f7 f9 idiv %ecx <== NOT EXECUTED 1249b6: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 1249b9: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1249bb: eb 35 jmp 1249f2 <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { 1249bd: 50 push %eax <== NOT EXECUTED 1249be: 50 push %eax <== NOT EXECUTED 1249bf: 53 push %ebx <== NOT EXECUTED 1249c0: 57 push %edi <== NOT EXECUTED 1249c1: e8 fe fe ff ff call 1248c4 <== NOT EXECUTED 1249c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1249c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1249cb: 74 24 je 1249f1 <== NOT EXECUTED 1249cd: eb 0d jmp 1249dc <== NOT EXECUTED for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 1249cf: 51 push %ecx <== NOT EXECUTED 1249d0: 51 push %ecx <== NOT EXECUTED 1249d1: 53 push %ebx <== NOT EXECUTED 1249d2: 57 push %edi <== NOT EXECUTED 1249d3: e8 4f fc ff ff call 124627 <== 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-- ) { 1249d8: 4b dec %ebx <== NOT EXECUTED 1249d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1249dc: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 1249df: 73 ee jae 1249cf <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 1249e1: e8 66 6a 00 00 call 12b44c <__errno> <== NOT EXECUTED 1249e6: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1249ec: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 1249ef: eb 0b jmp 1249fc <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 1249f1: 43 inc %ebx <== NOT EXECUTED 1249f2: 3b 5d f0 cmp -0x10(%ebp),%ebx <== NOT EXECUTED 1249f5: 76 c6 jbe 1249bd <== NOT EXECUTED /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 1249f7: 89 77 50 mov %esi,0x50(%edi) <== NOT EXECUTED 1249fa: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 1249fc: 89 d0 mov %edx,%eax <== NOT EXECUTED 1249fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124a01: 5b pop %ebx <== NOT EXECUTED 124a02: 5e pop %esi <== NOT EXECUTED 124a03: 5f pop %edi <== NOT EXECUTED 124a04: c9 leave <== NOT EXECUTED 124a05: c3 ret <== NOT EXECUTED 0012449a : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 12449a: 55 push %ebp <== NOT EXECUTED 12449b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12449d: 57 push %edi <== NOT EXECUTED 12449e: 56 push %esi <== NOT EXECUTED 12449f: 53 push %ebx <== NOT EXECUTED 1244a0: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1244a3: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1244a6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1244a9: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1244ac: 85 f6 test %esi,%esi <== NOT EXECUTED 1244ae: 75 11 jne 1244c1 <== NOT EXECUTED 1244b0: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 1244b5: 68 0c e2 13 00 push $0x13e20c <== NOT EXECUTED 1244ba: 68 86 03 00 00 push $0x386 <== NOT EXECUTED 1244bf: eb 15 jmp 1244d6 <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 1244c1: 83 7e 4c 05 cmpl $0x5,0x4c(%esi) <== NOT EXECUTED 1244c5: 74 19 je 1244e0 <== NOT EXECUTED 1244c7: 68 58 e1 13 00 push $0x13e158 <== NOT EXECUTED 1244cc: 68 0c e2 13 00 push $0x13e20c <== NOT EXECUTED 1244d1: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED 1244d6: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 1244db: e8 e4 57 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 1244e0: a1 70 7a 14 00 mov 0x147a70,%eax <== NOT EXECUTED 1244e5: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 1244e8: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 1244eb: 48 dec %eax <== NOT EXECUTED 1244ec: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 1244ee: 77 2f ja 12451f <== NOT EXECUTED #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 1244f0: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 1244f3: 85 ff test %edi,%edi <== NOT EXECUTED 1244f5: 74 23 je 12451a <== NOT EXECUTED if ( !p ) { 1244f7: 85 c0 test %eax,%eax <== NOT EXECUTED 1244f9: 75 10 jne 12450b <== NOT EXECUTED p = memfile_alloc_block(); 1244fb: e8 78 ff ff ff call 124478 <== NOT EXECUTED if ( !p ) 124500: 85 c0 test %eax,%eax <== NOT EXECUTED 124502: 0f 84 13 01 00 00 je 12461b <== NOT EXECUTED return 0; info->indirect = p; 124508: 89 46 54 mov %eax,0x54(%esi) <== NOT EXECUTED } return &info->indirect[ my_block ]; 12450b: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED 124512: 03 56 54 add 0x54(%esi),%edx <== NOT EXECUTED 124515: e9 03 01 00 00 jmp 12461d <== NOT EXECUTED } if ( !p ) return 0; return &info->indirect[ my_block ]; 12451a: 8d 14 98 lea (%eax,%ebx,4),%edx <== NOT EXECUTED 12451d: eb 6a jmp 124589 <== NOT EXECUTED /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 12451f: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 124522: 41 inc %ecx <== NOT EXECUTED 124523: 0f af 4d e4 imul -0x1c(%ebp),%ecx <== NOT EXECUTED 124527: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 12452a: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 12452c: 77 68 ja 124596 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 12452e: 2b 5d e4 sub -0x1c(%ebp),%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 124531: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124533: 31 d2 xor %edx,%edx <== NOT EXECUTED 124535: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 124538: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 12453b: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 12453d: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 124540: 85 ff test %edi,%edi <== NOT EXECUTED 124542: 74 34 je 124578 <== NOT EXECUTED if ( !p ) { 124544: 85 c0 test %eax,%eax <== NOT EXECUTED 124546: 75 10 jne 124558 <== NOT EXECUTED p = memfile_alloc_block(); 124548: e8 2b ff ff ff call 124478 <== NOT EXECUTED if ( !p ) 12454d: 85 c0 test %eax,%eax <== NOT EXECUTED 12454f: 0f 84 c6 00 00 00 je 12461b <== NOT EXECUTED return 0; info->doubly_indirect = p; 124555: 89 46 58 mov %eax,0x58(%esi) <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 124558: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 12455b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 12455d: 85 c0 test %eax,%eax <== NOT EXECUTED 12455f: 75 0f jne 124570 <== NOT EXECUTED p1 = memfile_alloc_block(); 124561: e8 12 ff ff ff call 124478 <== NOT EXECUTED if ( !p1 ) 124566: 85 c0 test %eax,%eax <== NOT EXECUTED 124568: 0f 84 ad 00 00 00 je 12461b <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 12456e: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 124570: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 124573: e9 85 00 00 00 jmp 1245fd <== NOT EXECUTED } if ( !p ) 124578: 85 c0 test %eax,%eax <== NOT EXECUTED 12457a: 0f 84 9b 00 00 00 je 12461b <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 124580: 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 ]; 124583: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 124586: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 124589: 85 c0 test %eax,%eax <== NOT EXECUTED 12458b: 0f 85 8c 00 00 00 jne 12461d <== NOT EXECUTED 124591: e9 85 00 00 00 jmp 12461b <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 124596: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 124599: 0f af 45 e4 imul -0x1c(%ebp),%eax <== NOT EXECUTED 12459d: 48 dec %eax <== NOT EXECUTED 12459e: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 1245a0: 77 79 ja 12461b <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 1245a2: 29 cb sub %ecx,%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 1245a4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1245a6: 31 d2 xor %edx,%edx <== NOT EXECUTED 1245a8: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 1245ab: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 1245ae: 31 d2 xor %edx,%edx <== NOT EXECUTED 1245b0: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 1245b3: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 1245b6: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 1245b8: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 1245bb: 85 ff test %edi,%edi <== NOT EXECUTED 1245bd: 74 43 je 124602 <== NOT EXECUTED if ( !p ) { 1245bf: 85 c0 test %eax,%eax <== NOT EXECUTED 1245c1: 75 0c jne 1245cf <== NOT EXECUTED p = memfile_alloc_block(); 1245c3: e8 b0 fe ff ff call 124478 <== NOT EXECUTED if ( !p ) 1245c8: 85 c0 test %eax,%eax <== NOT EXECUTED 1245ca: 74 4f je 12461b <== NOT EXECUTED return 0; info->triply_indirect = p; 1245cc: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 1245cf: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 1245d2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 1245d4: 85 c0 test %eax,%eax <== NOT EXECUTED 1245d6: 75 0b jne 1245e3 <== NOT EXECUTED p1 = memfile_alloc_block(); 1245d8: e8 9b fe ff ff call 124478 <== NOT EXECUTED if ( !p1 ) 1245dd: 85 c0 test %eax,%eax <== NOT EXECUTED 1245df: 74 3a je 12461b <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 1245e1: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 1245e3: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 1245e6: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED 1245e9: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 1245eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1245ed: 75 0b jne 1245fa <== NOT EXECUTED p2 = memfile_alloc_block(); 1245ef: e8 84 fe ff ff call 124478 <== NOT EXECUTED if ( !p2 ) 1245f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1245f6: 74 23 je 12461b <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 1245f8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 1245fa: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 1245fd: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED 124600: eb 1b jmp 12461d <== NOT EXECUTED } if ( !p ) 124602: 85 c0 test %eax,%eax <== NOT EXECUTED 124604: 74 15 je 12461b <== 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 ]; 124606: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !p1 ) 124609: 85 c0 test %eax,%eax <== NOT EXECUTED 12460b: 74 0e je 12461b <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 12460d: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 124610: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 124613: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 124616: 03 14 88 add (%eax,%ecx,4),%edx <== NOT EXECUTED 124619: eb 02 jmp 12461d <== NOT EXECUTED 12461b: 31 d2 xor %edx,%edx <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 12461d: 89 d0 mov %edx,%eax <== NOT EXECUTED 12461f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124622: 5b pop %ebx <== NOT EXECUTED 124623: 5e pop %esi <== NOT EXECUTED 124624: 5f pop %edi <== NOT EXECUTED 124625: c9 leave <== NOT EXECUTED 124626: c3 ret <== NOT EXECUTED 00107808 : * using the IMFS memory file type. * */ int IMFS_memfile_maximum_size( void ) { 107808: 55 push %ebp <== NOT EXECUTED 107809: 89 e5 mov %esp,%ebp <== NOT EXECUTED return IMFS_MEMFILE_MAXIMUM_SIZE; 10780b: 8b 0d ac 31 12 00 mov 0x1231ac,%ecx <== NOT EXECUTED 107811: 89 ca mov %ecx,%edx <== NOT EXECUTED 107813: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 107816: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 107819: 0f af c2 imul %edx,%eax <== NOT EXECUTED 10781c: 40 inc %eax <== NOT EXECUTED 10781d: 0f af c2 imul %edx,%eax <== NOT EXECUTED 107820: 48 dec %eax <== NOT EXECUTED 107821: 0f af c1 imul %ecx,%eax <== NOT EXECUTED } 107824: c9 leave <== NOT EXECUTED 107825: c3 ret <== NOT EXECUTED 00124d07 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 124d07: 55 push %ebp <== NOT EXECUTED 124d08: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124d0a: 57 push %edi <== NOT EXECUTED 124d0b: 56 push %esi <== NOT EXECUTED 124d0c: 53 push %ebx <== NOT EXECUTED 124d0d: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 124d10: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124d13: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 124d17: 75 11 jne 124d2a <== NOT EXECUTED 124d19: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 124d1e: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124d23: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED 124d28: eb 1d jmp 124d47 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 124d2a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124d2d: 8b 48 4c mov 0x4c(%eax),%ecx <== NOT EXECUTED 124d30: 8d 41 fb lea -0x5(%ecx),%eax <== NOT EXECUTED 124d33: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 124d36: 76 19 jbe 124d51 <== NOT EXECUTED 124d38: 68 bb e1 13 00 push $0x13e1bb <== NOT EXECUTED 124d3d: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124d42: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED 124d47: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 124d4c: e8 73 4f fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 124d51: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 124d55: 75 11 jne 124d68 <== NOT EXECUTED 124d57: 68 06 e2 13 00 push $0x13e206 <== NOT EXECUTED 124d5c: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124d61: 68 58 02 00 00 push $0x258 <== NOT EXECUTED 124d66: eb df jmp 124d47 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 124d68: 85 db test %ebx,%ebx <== NOT EXECUTED 124d6a: 75 13 jne 124d7f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 124d6c: e8 db 66 00 00 call 12b44c <__errno> <== NOT EXECUTED 124d71: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 124d77: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 124d7a: e9 86 01 00 00 jmp 124f05 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 124d7f: 83 f9 06 cmp $0x6,%ecx <== NOT EXECUTED 124d82: 75 47 jne 124dcb <== NOT EXECUTED unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 124d84: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124d87: 8b 52 50 mov 0x50(%edx),%edx <== NOT EXECUTED 124d8a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 124d8d: 29 ca sub %ecx,%edx <== NOT EXECUTED 124d8f: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 124d92: 39 da cmp %ebx,%edx <== NOT EXECUTED 124d94: 76 03 jbe 124d99 <== NOT EXECUTED 124d96: 89 5d c4 mov %ebx,-0x3c(%ebp) <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 124d99: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 124d9c: 8b 76 54 mov 0x54(%esi),%esi <== NOT EXECUTED 124d9f: 01 75 0c add %esi,0xc(%ebp) <== NOT EXECUTED 124da2: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 124da5: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 124da8: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 124dab: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 124dad: 50 push %eax <== NOT EXECUTED 124dae: 50 push %eax <== NOT EXECUTED 124daf: 6a 00 push $0x0 <== NOT EXECUTED 124db1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 124db4: 50 push %eax <== NOT EXECUTED 124db5: e8 da 52 fe ff call 10a094 <== NOT EXECUTED 124dba: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124dbd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 124dc0: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED return my_length; 124dc3: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 124dc6: e9 37 01 00 00 jmp 124f02 <== 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 ) 124dcb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124dce: 8b 48 50 mov 0x50(%eax),%ecx <== NOT EXECUTED 124dd1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 124dd4: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 124dd7: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 124dd9: 76 05 jbe 124de0 <== NOT EXECUTED my_length = the_jnode->info.file.size - start; 124ddb: 89 cb mov %ecx,%ebx <== NOT EXECUTED 124ddd: 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; 124de0: 8b 3d 70 7a 14 00 mov 0x147a70,%edi <== NOT EXECUTED 124de6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 124de9: 99 cltd <== NOT EXECUTED 124dea: f7 ff idiv %edi <== NOT EXECUTED 124dec: 89 d6 mov %edx,%esi <== NOT EXECUTED 124dee: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 124df1: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if ( start_offset ) { 124df4: 85 d2 test %edx,%edx <== NOT EXECUTED 124df6: 75 0f jne 124e07 <== NOT EXECUTED 124df8: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 124dfb: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED 124dfe: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED 124e05: eb 54 jmp 124e5b <== 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 ); 124e07: 50 push %eax <== NOT EXECUTED 124e08: 6a 00 push $0x0 <== NOT EXECUTED 124e0a: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 124e0d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124e10: e8 85 f6 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e18: 85 c0 test %eax,%eax <== NOT EXECUTED 124e1a: 75 14 jne 124e30 <== NOT EXECUTED 124e1c: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124e21: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124e26: 68 94 02 00 00 push $0x294 <== NOT EXECUTED 124e2b: e9 17 ff ff ff jmp 124d47 <== 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; 124e30: 89 fa mov %edi,%edx <== NOT EXECUTED 124e32: 29 f2 sub %esi,%edx <== NOT EXECUTED 124e34: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED 124e37: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 124e39: 76 03 jbe 124e3e <== NOT EXECUTED 124e3b: 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 ); 124e3e: 03 30 add (%eax),%esi <== NOT EXECUTED dest += to_copy; 124e40: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 124e43: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 124e46: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124e48: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED block++; 124e4b: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 124e4e: 40 inc %eax <== NOT EXECUTED 124e4f: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 124e52: 2b 5d c0 sub -0x40(%ebp),%ebx <== NOT EXECUTED 124e55: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 124e58: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 124e5b: 8b 0d 70 7a 14 00 mov 0x147a70,%ecx <== NOT EXECUTED 124e61: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 124e64: eb 42 jmp 124ea8 <== NOT EXECUTED while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124e66: 57 push %edi <== NOT EXECUTED 124e67: 6a 00 push $0x0 <== NOT EXECUTED 124e69: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 124e6c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124e6f: e8 26 f6 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124e74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e77: 85 c0 test %eax,%eax <== NOT EXECUTED 124e79: 75 14 jne 124e8f <== NOT EXECUTED 124e7b: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124e80: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124e85: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED 124e8a: e9 b8 fe ff ff jmp 124d47 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 124e8f: 8b 30 mov (%eax),%esi <== NOT EXECUTED 124e91: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 124e94: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 124e97: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED dest += to_copy; 124e99: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED block++; 124e9c: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 124e9f: 2b 5d e0 sub -0x20(%ebp),%ebx <== NOT EXECUTED copied += to_copy; 124ea2: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 124ea5: 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 ) { 124ea8: 3b 1d 70 7a 14 00 cmp 0x147a70,%ebx <== NOT EXECUTED 124eae: 73 b6 jae 124e66 <== NOT EXECUTED * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 124eb0: 85 db test %ebx,%ebx <== NOT EXECUTED 124eb2: 74 35 je 124ee9 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124eb4: 56 push %esi <== NOT EXECUTED 124eb5: 6a 00 push $0x0 <== NOT EXECUTED 124eb7: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 124eba: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124ebd: e8 d8 f5 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124ec2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124ec5: 85 c0 test %eax,%eax <== NOT EXECUTED 124ec7: 75 14 jne 124edd <== NOT EXECUTED 124ec9: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124ece: 68 40 e2 13 00 push $0x13e240 <== NOT EXECUTED 124ed3: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED 124ed8: e9 6a fe ff ff jmp 124d47 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 124edd: 8b 30 mov (%eax),%esi <== NOT EXECUTED 124edf: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 124ee2: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 124ee4: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED copied += my_length; 124ee6: 01 5d d8 add %ebx,-0x28(%ebp) <== NOT EXECUTED } IMFS_update_atime( the_jnode ); 124ee9: 53 push %ebx <== NOT EXECUTED 124eea: 53 push %ebx <== NOT EXECUTED 124eeb: 6a 00 push $0x0 <== NOT EXECUTED 124eed: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 124ef0: 50 push %eax <== NOT EXECUTED 124ef1: e8 9e 51 fe ff call 10a094 <== NOT EXECUTED 124ef6: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124ef9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 124efc: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED return copied; 124eff: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 124f02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 124f05: 89 c8 mov %ecx,%eax <== NOT EXECUTED 124f07: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124f0a: 5b pop %ebx <== NOT EXECUTED 124f0b: 5e pop %esi <== NOT EXECUTED 124f0c: 5f pop %edi <== NOT EXECUTED 124f0d: c9 leave <== NOT EXECUTED 124f0e: c3 ret <== NOT EXECUTED 001246bb : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 1246bb: 55 push %ebp <== NOT EXECUTED 1246bc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1246be: 57 push %edi <== NOT EXECUTED 1246bf: 56 push %esi <== NOT EXECUTED 1246c0: 53 push %ebx <== NOT EXECUTED 1246c1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1246c4: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 1246c8: 75 11 jne 1246db <== NOT EXECUTED 1246ca: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 1246cf: 68 54 e2 13 00 push $0x13e254 <== NOT EXECUTED 1246d4: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED 1246d9: eb 18 jmp 1246f3 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1246db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1246de: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 1246e2: 74 19 je 1246fd <== NOT EXECUTED 1246e4: 68 58 e1 13 00 push $0x13e158 <== NOT EXECUTED 1246e9: 68 54 e2 13 00 push $0x13e254 <== NOT EXECUTED 1246ee: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED 1246f3: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 1246f8: e8 c7 55 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; 1246fd: 8b 3d 70 7a 14 00 mov 0x147a70,%edi <== NOT EXECUTED 124703: c1 ef 02 shr $0x2,%edi <== NOT EXECUTED * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 124706: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124709: 83 7a 54 00 cmpl $0x0,0x54(%edx) <== NOT EXECUTED 12470d: 74 11 je 124720 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); 12470f: 50 push %eax <== NOT EXECUTED 124710: 50 push %eax <== NOT EXECUTED 124711: 57 push %edi <== NOT EXECUTED 124712: 89 d0 mov %edx,%eax <== NOT EXECUTED 124714: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 124717: 50 push %eax <== NOT EXECUTED 124718: e8 34 ff ff ff call 124651 <== NOT EXECUTED 12471d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->doubly_indirect ) { 124720: 31 db xor %ebx,%ebx <== NOT EXECUTED 124722: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124725: 83 78 58 00 cmpl $0x0,0x58(%eax) <== NOT EXECUTED 124729: 75 24 jne 12474f <== NOT EXECUTED 12472b: eb 40 jmp 12476d <== NOT EXECUTED for ( i=0 ; idoubly_indirect[i] ) { 12472d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124730: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED 124733: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED 12473a: 83 3c 98 00 cmpl $0x0,(%eax,%ebx,4) <== NOT EXECUTED 12473e: 74 0e je 12474e <== NOT EXECUTED memfile_free_blocks_in_table( 124740: 56 push %esi <== NOT EXECUTED 124741: 56 push %esi <== NOT EXECUTED 124742: 57 push %edi <== NOT EXECUTED 124743: 01 d0 add %edx,%eax <== NOT EXECUTED 124745: 50 push %eax <== NOT EXECUTED 124746: e8 06 ff ff ff call 124651 <== NOT EXECUTED 12474b: 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 ); 12475b: 53 push %ebx <== NOT EXECUTED 12475c: 53 push %ebx <== NOT EXECUTED 12475d: 57 push %edi <== NOT EXECUTED 12475e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124761: 83 c0 58 add $0x58,%eax <== NOT EXECUTED 124764: 50 push %eax <== NOT EXECUTED 124765: e8 e7 fe ff ff call 124651 <== NOT EXECUTED 12476a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->triply_indirect ) { 12476d: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 124774: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124777: 83 78 5c 00 cmpl $0x0,0x5c(%eax) <== NOT EXECUTED 12477b: 75 5c jne 1247d9 <== NOT EXECUTED 12477d: eb 79 jmp 1247f8 <== NOT EXECUTED 12477f: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 124782: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 124785: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED for ( i=0 ; itriply_indirect[i]; 124788: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12478b: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 12478e: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 124791: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 124794: 85 c0 test %eax,%eax <== NOT EXECUTED 124796: 74 4e je 1247e6 <== NOT EXECUTED break; 124798: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12479a: 31 f6 xor %esi,%esi <== NOT EXECUTED 12479c: eb 15 jmp 1247b3 <== NOT EXECUTED for ( j=0 ; j <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 1247a3: 51 push %ecx <== NOT EXECUTED 1247a4: 51 push %ecx <== NOT EXECUTED 1247a5: 57 push %edi <== NOT EXECUTED 1247a6: 53 push %ebx <== NOT EXECUTED 1247a7: e8 a5 fe ff ff call 124651 <== NOT EXECUTED 1247ac: 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( 1247bf: 52 push %edx <== NOT EXECUTED 1247c0: 52 push %edx <== NOT EXECUTED 1247c1: 57 push %edi <== NOT EXECUTED 1247c2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1247c5: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 1247c8: 01 45 f0 add %eax,-0x10(%ebp) <== NOT EXECUTED 1247cb: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1247ce: e8 7e fe ff ff call 124651 <== 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( 1247e6: 50 push %eax <== NOT EXECUTED 1247e7: 50 push %eax <== NOT EXECUTED 1247e8: 57 push %edi <== NOT EXECUTED 1247e9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1247ec: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED 1247ef: 50 push %eax <== NOT EXECUTED 1247f0: e8 5c fe ff ff call 124651 <== NOT EXECUTED 1247f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 1247f8: 31 c0 xor %eax,%eax <== NOT EXECUTED 1247fa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1247fd: 5b pop %ebx <== NOT EXECUTED 1247fe: 5e pop %esi <== NOT EXECUTED 1247ff: 5f pop %edi <== NOT EXECUTED 124800: c9 leave <== NOT EXECUTED 124801: c3 ret <== NOT EXECUTED 00124627 : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 124627: 55 push %ebp <== NOT EXECUTED 124628: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12462a: 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 ); 12462d: 6a 00 push $0x0 <== NOT EXECUTED 12462f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124632: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124635: e8 60 fe ff ff call 12449a <== NOT EXECUTED ptr = *block_entry_ptr; 12463a: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_entry_ptr = 0; 12463c: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 124642: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 124645: e8 15 fe ff ff call 12445f <== NOT EXECUTED return 1; } 12464a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 12464f: c9 leave <== NOT EXECUTED 124650: c3 ret <== NOT EXECUTED 00124a99 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 124a99: 55 push %ebp <== NOT EXECUTED 124a9a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124a9c: 57 push %edi <== NOT EXECUTED 124a9d: 56 push %esi <== NOT EXECUTED 124a9e: 53 push %ebx <== NOT EXECUTED 124a9f: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 124aa2: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 124aa6: 75 11 jne 124ab9 <== NOT EXECUTED 124aa8: 68 05 e1 13 00 push $0x13e105 <== NOT EXECUTED 124aad: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124ab2: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED 124ab7: eb 18 jmp 124ad1 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 124ab9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124abc: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 124ac0: 74 19 je 124adb <== NOT EXECUTED 124ac2: 68 58 e1 13 00 push $0x13e158 <== NOT EXECUTED 124ac7: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124acc: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED 124ad1: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 124ad6: e8 e9 51 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 124adb: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 124adf: 75 11 jne 124af2 <== NOT EXECUTED 124ae1: 68 9f da 13 00 push $0x13da9f <== NOT EXECUTED 124ae6: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124aeb: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED 124af0: eb df jmp 124ad1 <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 124af2: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 124af6: 75 0d jne 124b05 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 124af8: e8 4f 69 00 00 call 12b44c <__errno> <== NOT EXECUTED 124afd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 124b03: eb 29 jmp 124b2e <== 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; 124b05: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 124b08: 03 45 0c add 0xc(%ebp),%eax <== NOT EXECUTED if ( last_byte > the_jnode->info.file.size ) { 124b0b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124b0e: 3b 42 50 cmp 0x50(%edx),%eax <== NOT EXECUTED 124b11: 76 27 jbe 124b3a <== NOT EXECUTED status = IMFS_memfile_extend( the_jnode, last_byte ); 124b13: 51 push %ecx <== NOT EXECUTED 124b14: 51 push %ecx <== NOT EXECUTED 124b15: 50 push %eax <== NOT EXECUTED 124b16: 52 push %edx <== NOT EXECUTED 124b17: e8 17 fe ff ff call 124933 <== NOT EXECUTED if ( status ) 124b1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124b1f: 85 c0 test %eax,%eax <== NOT EXECUTED 124b21: 74 17 je 124b3a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 124b23: e8 24 69 00 00 call 12b44c <__errno> <== NOT EXECUTED 124b28: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 124b2e: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 124b35: e9 24 01 00 00 jmp 124c5e <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 124b3a: 8b 1d 70 7a 14 00 mov 0x147a70,%ebx <== NOT EXECUTED 124b40: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 124b43: 99 cltd <== NOT EXECUTED 124b44: f7 fb idiv %ebx <== NOT EXECUTED 124b46: 89 d7 mov %edx,%edi <== NOT EXECUTED 124b48: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 124b4b: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if ( start_offset ) { 124b4e: 85 d2 test %edx,%edx <== NOT EXECUTED 124b50: 75 12 jne 124b64 <== NOT EXECUTED 124b52: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 124b55: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 124b58: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 124b5b: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 124b62: eb 50 jmp 124bb4 <== 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 ); 124b64: 50 push %eax <== NOT EXECUTED 124b65: 6a 00 push $0x0 <== NOT EXECUTED 124b67: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 124b6a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124b6d: e8 28 f9 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124b75: 85 c0 test %eax,%eax <== NOT EXECUTED 124b77: 75 14 jne 124b8d <== NOT EXECUTED 124b79: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124b7e: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124b83: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED 124b88: e9 44 ff ff ff jmp 124ad1 <== 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; 124b8d: 89 da mov %ebx,%edx <== NOT EXECUTED 124b8f: 29 fa sub %edi,%edx <== NOT EXECUTED 124b91: 3b 55 14 cmp 0x14(%ebp),%edx <== NOT EXECUTED 124b94: 76 03 jbe 124b99 <== NOT EXECUTED 124b96: 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 ); 124b99: 03 38 add (%eax),%edi <== NOT EXECUTED src += to_copy; 124b9b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 124b9e: 89 d1 mov %edx,%ecx <== NOT EXECUTED 124ba0: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124ba2: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 124ba5: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 124ba8: 40 inc %eax <== NOT EXECUTED 124ba9: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 124bac: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 124baf: 29 d3 sub %edx,%ebx <== NOT EXECUTED copied += to_copy; 124bb1: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 124bb4: 8b 15 70 7a 14 00 mov 0x147a70,%edx <== NOT EXECUTED 124bba: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 124bbd: eb 42 jmp 124c01 <== NOT EXECUTED while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124bbf: 57 push %edi <== NOT EXECUTED 124bc0: 6a 00 push $0x0 <== NOT EXECUTED 124bc2: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 124bc5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124bc8: e8 cd f8 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124bcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124bd0: 85 c0 test %eax,%eax <== NOT EXECUTED 124bd2: 75 14 jne 124be8 <== NOT EXECUTED 124bd4: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124bd9: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124bde: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED 124be3: e9 e9 fe ff ff jmp 124ad1 <== 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 ); 124be8: 8b 38 mov (%eax),%edi <== NOT EXECUTED src += to_copy; 124bea: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 124bed: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 124bf0: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124bf2: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 124bf5: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 124bf8: 2b 5d c4 sub -0x3c(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 124bfb: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 124bfe: 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 ) { 124c01: 3b 1d 70 7a 14 00 cmp 0x147a70,%ebx <== NOT EXECUTED 124c07: 73 b6 jae 124bbf <== NOT EXECUTED */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 124c09: 85 db test %ebx,%ebx <== NOT EXECUTED 124c0b: 74 35 je 124c42 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 124c0d: 56 push %esi <== NOT EXECUTED 124c0e: 6a 00 push $0x0 <== NOT EXECUTED 124c10: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 124c13: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124c16: e8 7f f8 ff ff call 12449a <== NOT EXECUTED assert( block_ptr ); 124c1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124c1e: 85 c0 test %eax,%eax <== NOT EXECUTED 124c20: 75 14 jne 124c36 <== NOT EXECUTED 124c22: 68 88 e1 13 00 push $0x13e188 <== NOT EXECUTED 124c27: 68 2c e2 13 00 push $0x13e22c <== NOT EXECUTED 124c2c: 68 44 03 00 00 push $0x344 <== NOT EXECUTED 124c31: e9 9b fe ff ff jmp 124ad1 <== 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 ); 124c36: 8b 38 mov (%eax),%edi <== NOT EXECUTED 124c38: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 124c3b: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 124c3d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED my_length = 0; copied += to_copy; 124c3f: 01 5d dc add %ebx,-0x24(%ebp) <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); 124c42: 53 push %ebx <== NOT EXECUTED 124c43: 53 push %ebx <== NOT EXECUTED 124c44: 6a 00 push $0x0 <== NOT EXECUTED 124c46: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 124c49: 50 push %eax <== NOT EXECUTED 124c4a: e8 45 54 fe ff call 10a094 <== NOT EXECUTED 124c4f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124c52: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124c55: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 124c58: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED 124c5b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return copied; } 124c5e: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 124c61: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124c64: 5b pop %ebx <== NOT EXECUTED 124c65: 5e pop %esi <== NOT EXECUTED 124c66: 5f pop %edi <== NOT EXECUTED 124c67: c9 leave <== NOT EXECUTED 124c68: c3 ret <== NOT EXECUTED 0010c99c : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10c99c: 55 push %ebp <== NOT EXECUTED 10c99d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c99f: 57 push %edi <== NOT EXECUTED 10c9a0: 56 push %esi <== NOT EXECUTED 10c9a1: 53 push %ebx <== NOT EXECUTED 10c9a2: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 10c9a5: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c9a8: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10c9ab: 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 ); 10c9ae: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c9b1: 50 push %eax <== NOT EXECUTED 10c9b2: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10c9b5: 50 push %eax <== NOT EXECUTED 10c9b6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c9b9: e8 7a fe ff ff call 10c838 <== NOT EXECUTED /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10c9be: 89 f8 mov %edi,%eax <== NOT EXECUTED 10c9c0: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10c9c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9c8: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 10c9cd: 74 34 je 10ca03 <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10c9cf: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED 10c9d4: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED 10c9d9: 74 2d je 10ca08 <== NOT EXECUTED type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10c9db: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 10c9e0: 74 07 je 10c9e9 <== NOT EXECUTED 10c9e2: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 10c9e7: 75 0d jne 10c9f6 <== NOT EXECUTED type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10c9e9: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED 10c9ec: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED 10c9ef: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED 10c9f4: eb 12 jmp 10ca08 <== NOT EXECUTED } else { rtems_set_errno_and_return_minus_one( EINVAL ); 10c9f6: e8 bd 26 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10c9fb: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ca01: eb 2e jmp 10ca31 <== NOT EXECUTED 10ca03: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10ca08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca0b: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10ca0e: 50 push %eax <== NOT EXECUTED 10ca0f: 57 push %edi <== NOT EXECUTED 10ca10: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10ca13: 50 push %eax <== NOT EXECUTED 10ca14: 52 push %edx <== NOT EXECUTED 10ca15: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10ca18: e8 e3 1c 00 00 call 10e700 <== NOT EXECUTED new_name, mode, &info ); if ( !new_node ) 10ca1d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ca20: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ca22: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca24: 75 0e jne 10ca34 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 10ca26: e8 8d 26 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10ca2b: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ca31: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED return 0; } 10ca34: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ca36: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca39: 5b pop %ebx <== NOT EXECUTED 10ca3a: 5e pop %esi <== NOT EXECUTED 10ca3b: 5f pop %edi <== NOT EXECUTED 10ca3c: c9 leave <== NOT EXECUTED 10ca3d: 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 6d 1a 02 00 call 12b44c <__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 0010ca40 : #include "imfs.h" rtems_filesystem_node_types_t IMFS_node_type( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10ca40: 55 push %ebp <== NOT EXECUTED 10ca41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca43: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca46: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10ca48: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED IMFS_jnode_t *node; node = pathloc->node_access; return node->type; } 10ca4b: c9 leave <== NOT EXECUTED 10ca4c: c3 ret <== NOT EXECUTED 00107826 : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 107826: 55 push %ebp <== NOT EXECUTED 107827: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107829: 53 push %ebx <== NOT EXECUTED 10782a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10782d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED assert( the_jnode ); 107830: 85 db test %ebx,%ebx <== NOT EXECUTED 107832: 75 11 jne 107845 <== NOT EXECUTED 107834: 68 c6 ca 11 00 push $0x11cac6 <== NOT EXECUTED 107839: 68 68 cc 11 00 push $0x11cc68 <== NOT EXECUTED 10783e: 6a 38 push $0x38 <== NOT EXECUTED 107840: e9 98 00 00 00 jmp 1078dd <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 107845: 50 push %eax <== NOT EXECUTED 107846: 50 push %eax <== NOT EXECUTED 107847: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 10784c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10784f: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 107852: 50 push %eax <== NOT EXECUTED 107853: e8 94 b3 00 00 call 112bec <== NOT EXECUTED switch( the_jnode->type ) { 107858: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10785b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10785e: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 107861: 83 fa 05 cmp $0x5,%edx <== NOT EXECUTED 107864: 0f 87 9a 00 00 00 ja 107904 <== NOT EXECUTED 10786a: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 10786f: ff 24 95 3c cc 11 00 jmp *0x11cc3c(,%edx,4) <== NOT EXECUTED case IMFS_DIRECTORY: fprintf(stdout, "/" ); 107876: 51 push %ecx <== NOT EXECUTED 107877: 51 push %ecx <== NOT EXECUTED 107878: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10787b: 6a 2f push $0x2f <== NOT EXECUTED 10787d: e8 9a b2 00 00 call 112b1c <== NOT EXECUTED 107882: eb 2b jmp 1078af <== NOT EXECUTED break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 107884: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED 107887: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 10788a: 68 1c cb 11 00 push $0x11cb1c <== NOT EXECUTED 10788f: eb 16 jmp 1078a7 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 107891: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED 107894: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 107897: 68 2f cb 11 00 push $0x11cb2f <== NOT EXECUTED 10789c: eb 09 jmp 1078a7 <== NOT EXECUTED the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 10789e: 52 push %edx <== NOT EXECUTED 10789f: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 1078a2: 68 3e cb 11 00 push $0x11cb3e <== NOT EXECUTED 1078a7: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1078aa: e8 31 b2 00 00 call 112ae0 <== NOT EXECUTED 1078af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1078b2: c7 45 08 d9 cd 11 00 movl $0x11cdd9,0x8(%ebp) <== NOT EXECUTED } 1078b9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1078bc: c9 leave <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1078bd: e9 fe c8 00 00 jmp 1141c0 <== NOT EXECUTED (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 1078c2: 53 push %ebx <== NOT EXECUTED 1078c3: 53 push %ebx <== NOT EXECUTED 1078c4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1078c7: 68 4a cb 11 00 push $0x11cb4a <== NOT EXECUTED 1078cc: e8 1b b3 00 00 call 112bec <== NOT EXECUTED assert(0); 1078d1: 68 b3 c4 11 00 push $0x11c4b3 <== NOT EXECUTED 1078d6: 68 68 cc 11 00 push $0x11cc68 <== NOT EXECUTED 1078db: 6a 5d push $0x5d <== NOT EXECUTED 1078dd: 68 d0 ca 11 00 push $0x11cad0 <== NOT EXECUTED 1078e2: e8 55 06 00 00 call 107f3c <__assert_func> <== NOT EXECUTED break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 1078e7: 51 push %ecx <== NOT EXECUTED 1078e8: 51 push %ecx <== NOT EXECUTED 1078e9: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1078ec: 68 4a cb 11 00 push $0x11cb4a <== NOT EXECUTED 1078f1: e8 f6 b2 00 00 call 112bec <== NOT EXECUTED assert(0); 1078f6: 68 b3 c4 11 00 push $0x11c4b3 <== NOT EXECUTED 1078fb: 68 68 cc 11 00 push $0x11cc68 <== NOT EXECUTED 107900: 6a 62 push $0x62 <== NOT EXECUTED 107902: eb d9 jmp 1078dd <== NOT EXECUTED break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 107904: 52 push %edx <== NOT EXECUTED 107905: 50 push %eax <== NOT EXECUTED 107906: 68 5e cb 11 00 push $0x11cb5e <== NOT EXECUTED 10790b: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 107910: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107913: e8 c8 b1 00 00 call 112ae0 <== NOT EXECUTED assert(0); 107918: 68 b3 c4 11 00 push $0x11c4b3 <== NOT EXECUTED 10791d: 68 68 cc 11 00 push $0x11cc68 <== NOT EXECUTED 107922: 6a 67 push $0x67 <== NOT EXECUTED 107924: eb b7 jmp 1078dd <== 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 2c 1a 02 00 call 12b44c <__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 0010ca50 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10ca50: 55 push %ebp <== NOT EXECUTED 10ca51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca53: 56 push %esi <== NOT EXECUTED 10ca54: 53 push %ebx <== NOT EXECUTED 10ca55: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca58: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10ca5b: 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 ) { 10ca5d: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 10ca61: 74 13 je 10ca76 <== NOT EXECUTED 10ca63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca66: 53 push %ebx <== NOT EXECUTED 10ca67: e8 68 12 00 00 call 10dcd4 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10ca6c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10ca73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10ca76: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 10ca7a: 50 push %eax <== NOT EXECUTED 10ca7b: 50 push %eax <== NOT EXECUTED 10ca7c: 6a 00 push $0x0 <== NOT EXECUTED 10ca7e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ca81: 50 push %eax <== NOT EXECUTED 10ca82: e8 5d 03 00 00 call 10cde4 <== NOT EXECUTED 10ca87: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ca8a: 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) ) { 10ca8d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ca90: e8 ff 03 00 00 call 10ce94 <== NOT EXECUTED 10ca95: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca98: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca9a: 75 40 jne 10cadc <== NOT EXECUTED 10ca9c: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 10caa1: 75 39 jne 10cadc <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10caa3: 8b 15 4c b5 11 00 mov 0x11b54c,%edx <== NOT EXECUTED 10caa9: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10caac: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10caae: 75 07 jne 10cab7 <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 10cab0: 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 ) { 10cab7: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10cabb: 75 13 jne 10cad0 <== NOT EXECUTED if ( the_jnode->info.sym_link.name ) 10cabd: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10cac0: 85 c0 test %eax,%eax <== NOT EXECUTED 10cac2: 74 0c je 10cad0 <== NOT EXECUTED free( (void*) the_jnode->info.sym_link.name ); 10cac4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cac7: 50 push %eax <== NOT EXECUTED 10cac8: e8 9b 99 ff ff call 106468 <== NOT EXECUTED 10cacd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } free( the_jnode ); 10cad0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cad3: 53 push %ebx <== NOT EXECUTED 10cad4: e8 8f 99 ff ff call 106468 <== NOT EXECUTED 10cad9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10cadc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cade: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cae1: 5b pop %ebx <== NOT EXECUTED 10cae2: 5e pop %esi <== NOT EXECUTED 10cae3: c9 leave <== NOT EXECUTED 10cae4: c3 ret <== NOT EXECUTED 0010cae8 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10cae8: 55 push %ebp <== NOT EXECUTED 10cae9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caeb: 53 push %ebx <== NOT EXECUTED 10caec: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10caef: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10caf2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10caf5: 8b 08 mov (%eax),%ecx <== NOT EXECUTED switch ( the_jnode->type ) { 10caf7: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10cafa: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10cafd: 74 25 je 10cb24 <== NOT EXECUTED 10caff: 7f 07 jg 10cb08 <== NOT EXECUTED 10cb01: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10cb04: 75 27 jne 10cb2d <== NOT EXECUTED 10cb06: eb 07 jmp 10cb0f <== NOT EXECUTED 10cb08: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10cb0b: 7f 20 jg 10cb2d <== NOT EXECUTED 10cb0d: eb 0d jmp 10cb1c <== NOT EXECUTED case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10cb0f: 8b 51 54 mov 0x54(%ecx),%edx <== NOT EXECUTED 10cb12: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10cb15: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10cb17: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10cb1a: eb 21 jmp 10cb3d <== NOT EXECUTED break; case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10cb1c: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10cb1f: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 10cb22: eb 19 jmp 10cb3d <== NOT EXECUTED break; case IMFS_SYM_LINK: buf->st_size = 0; 10cb24: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10cb2b: eb 10 jmp 10cb3d <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10cb2d: e8 86 25 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cb32: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cb38: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cb3b: eb 36 jmp 10cb73 <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 10cb3d: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10cb40: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 10cb43: 8b 41 34 mov 0x34(%ecx),%eax <== NOT EXECUTED 10cb46: 66 89 43 10 mov %ax,0x10(%ebx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 10cb4a: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 10cb4d: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 10cb50: 8b 41 3c mov 0x3c(%ecx),%eax <== NOT EXECUTED 10cb53: 66 89 43 12 mov %ax,0x12(%ebx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 10cb57: 66 8b 41 3e mov 0x3e(%ecx),%ax <== NOT EXECUTED 10cb5b: 66 89 43 14 mov %ax,0x14(%ebx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 10cb5f: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10cb62: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 10cb65: 8b 41 44 mov 0x44(%ecx),%eax <== NOT EXECUTED 10cb68: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 10cb6b: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 10cb6e: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED 10cb71: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10cb73: 5a pop %edx <== NOT EXECUTED 10cb74: 5b pop %ebx <== NOT EXECUTED 10cb75: c9 leave <== NOT EXECUTED 10cb76: 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 ec 5e 02 00 call 12f950 <== 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 d9 19 02 00 call 12b44c <__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 0b 46 01 00 call 11e0a0 <== 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 9e 19 02 00 call 12b44c <__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 68 19 02 00 call 12b44c <__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 d1 46 01 00 call 11e1dc <== 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 c9 18 02 00 call 12b44c <__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 b6 18 02 00 call 12b44c <__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 b4 ba 11 00 mov 0x11bab4,%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 b8 ba 11 00 mov 0x11bab8,%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 10 d7 11 00 mov 0x11d710,%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 30 d5 11 00 push $0x11d530 <== NOT EXECUTED 10663f: e8 bc 39 00 00 call 10a000 <_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 13 31 00 00 call 109768 <== NOT EXECUTED rtems_print_buffer( (start + length) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif MSBUMP(space_available, length); 106655: 01 1d 88 d5 11 00 add %ebx,0x11d588 <== 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 58 7a 14 00 mov 0x147a58,%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 5c ab 15 00 00 cmpl $0x0,0x15ab5c <== 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 58 ab 15 00 mov $0x15ab58,%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 11 b6 13 00 push $0x13b611 <== NOT EXECUTED 10865a: ff 35 54 7a 14 00 pushl 0x147a54 <== 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 1e b6 13 00 push $0x13b61e <== NOT EXECUTED 108670: ff 35 54 7a 14 00 pushl 0x147a54 <== 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 2c b6 13 00 push $0x13b62c <== NOT EXECUTED 108694: ff 35 54 7a 14 00 pushl 0x147a54 <== NOT EXECUTED 10869a: ff 15 58 7a 14 00 call *0x147a58 <== 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 50 7a 14 00 00 cmpl $0x0,0x147a50 <== NOT EXECUTED 1086aa: a1 58 7a 14 00 mov 0x147a58,%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 4a b6 13 00 push $0x13b64a <== 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 57 b6 13 00 push $0x13b657 <== NOT EXECUTED 1086c3: ff 35 54 7a 14 00 pushl 0x147a54 <== 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 50 7a 14 00 00 cmpl $0x0,0x147a50 <== 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 48 ab 15 00 0d movl $0xfeedf00d,0x15ab48 <== NOT EXECUTED 10889e: f0 ed fe <== NOT EXECUTED p[1] = 0x0BAD0D06; 1088a1: c7 05 4c ab 15 00 06 movl $0xbad0d06,0x15ab4c <== NOT EXECUTED 1088a8: 0d ad 0b <== NOT EXECUTED p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 1088ab: c7 05 50 ab 15 00 0d movl $0xdeadf00d,0x15ab50 <== NOT EXECUTED 1088b2: f0 ad de <== NOT EXECUTED p[3] = 0x600D0D06; 1088b5: c7 05 54 ab 15 00 06 movl $0x600d0d06,0x15ab54 <== 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 dc ac 15 00 mov 0x15acdc,%edi <== NOT EXECUTED 1088c5: 85 ff test %edi,%edi <== NOT EXECUTED 1088c7: 74 1d je 1088e6 <== NOT EXECUTED 1088c9: a1 9c ac 15 00 mov 0x15ac9c,%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 5c ab 15 00 mov %edi,0x15ab5c <== 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 58 ab 15 00 mov %ecx,0x15ab58 <== 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 50 7a 14 00 01 movl $0x1,0x147a50 <== 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 be b6 13 00 push $0x13b6be <== 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 fc b6 13 00 push $0x13b6fc <== 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 2a b7 13 00 push $0x13b72a <== 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 c7 56 00 00 call 10de7c <== NOT EXECUTED 001099f0 <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 1099f0: 55 push %ebp <== NOT EXECUTED 1099f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099f3: 57 push %edi <== NOT EXECUTED 1099f4: 56 push %esi <== NOT EXECUTED 1099f5: 53 push %ebx <== NOT EXECUTED 1099f6: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 1099f9: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 1099fc: be 7c 72 11 00 mov $0x11727c,%esi <== NOT EXECUTED 109a01: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109a06: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 109a08: 68 64 d7 11 00 push $0x11d764 <== NOT EXECUTED 109a0d: e8 4a 08 00 00 call 10a25c <_Objects_Allocate> <== NOT EXECUTED 109a12: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 109a14: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109a17: 6a 01 push $0x1 <== NOT EXECUTED 109a19: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109a1c: 50 push %eax <== NOT EXECUTED 109a1d: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 109a20: 50 push %eax <== NOT EXECUTED 109a21: e8 f6 01 00 00 call 109c1c <_CORE_mutex_Initialize> <== NOT EXECUTED 109a26: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 109a2a: a1 80 d7 11 00 mov 0x11d780,%eax <== NOT EXECUTED 109a2f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109a32: 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; 109a39: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109a3c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 109a3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109a41: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109a44: 5b pop %ebx <== NOT EXECUTED 109a45: 5e pop %esi <== NOT EXECUTED 109a46: 5f pop %edi <== NOT EXECUTED 109a47: c9 leave <== NOT EXECUTED 109a48: c3 ret <== NOT EXECUTED 00109a70 <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 109a70: 55 push %ebp <== NOT EXECUTED 109a71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a73: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 109a76: 6a 00 push $0x0 <== NOT EXECUTED 109a78: 6a 00 push $0x0 <== NOT EXECUTED 109a7a: 6a 74 push $0x74 <== NOT EXECUTED 109a7c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109a7f: 6a 02 push $0x2 <== NOT EXECUTED 109a81: 6a 01 push $0x1 <== NOT EXECUTED 109a83: 68 64 d7 11 00 push $0x11d764 <== NOT EXECUTED 109a88: e8 6b 0c 00 00 call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 109a8d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 109a90: c9 leave <== NOT EXECUTED 109a91: c3 ret <== NOT EXECUTED 00109a4c <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 109a4c: 55 push %ebp <== NOT EXECUTED 109a4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a4f: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109a52: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 109a55: 9c pushf <== NOT EXECUTED 109a56: fa cli <== NOT EXECUTED 109a57: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 109a58: 52 push %edx <== NOT EXECUTED 109a59: 6a 00 push $0x0 <== NOT EXECUTED 109a5b: 6a 01 push $0x1 <== NOT EXECUTED 109a5d: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109a60: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109a63: 50 push %eax <== NOT EXECUTED 109a64: e8 9f 02 00 00 call 109d08 <_CORE_mutex_Seize> <== NOT EXECUTED 109a69: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 109a6c: c9 leave <== NOT EXECUTED 109a6d: c3 ret <== NOT EXECUTED 00109a94 <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 109a94: 55 push %ebp <== NOT EXECUTED 109a95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a9a: 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 109a9d: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 109aa2: 40 inc %eax <== NOT EXECUTED 109aa3: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 109aa8: 6a 00 push $0x0 <== NOT EXECUTED 109aaa: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 109aad: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 109ab0: 52 push %edx <== NOT EXECUTED 109ab1: e8 e2 02 00 00 call 109d98 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109ab6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109ab9: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109aba: e9 a1 13 00 00 jmp 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED 001099d6 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 1099d6: 55 push %ebp <== NOT EXECUTED 1099d7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099d9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 1099dc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099df: 68 9c d8 11 00 push $0x11d89c <== NOT EXECUTED 1099e4: e8 d7 00 00 00 call 109ac0 <_Chain_Append> <== NOT EXECUTED 1099e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1099ec: c9 leave <== NOT EXECUTED 1099ed: c3 ret <== NOT EXECUTED 00109934 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 109934: 55 push %ebp <== NOT EXECUTED 109935: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109937: c7 05 9c d8 11 00 a0 movl $0x11d8a0,0x11d89c <== NOT EXECUTED 10993e: d8 11 00 <== NOT EXECUTED 109941: c7 05 a0 d8 11 00 00 movl $0x0,0x11d8a0 <== NOT EXECUTED 109948: 00 00 00 <== NOT EXECUTED 10994b: c7 05 a4 d8 11 00 9c movl $0x11d89c,0x11d8a4 <== NOT EXECUTED 109952: d8 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 109955: c9 leave <== NOT EXECUTED 109956: c3 ret <== NOT EXECUTED 0010997d <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10997d: 55 push %ebp <== NOT EXECUTED 10997e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109980: 53 push %ebx <== NOT EXECUTED 109981: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 109984: 8b 1d 9c d8 11 00 mov 0x11d89c,%ebx <== NOT EXECUTED 10998a: eb 0b jmp 109997 <_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 ) 10998c: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10998f: 85 c0 test %eax,%eax <== NOT EXECUTED 109991: 74 02 je 109995 <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 109993: 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 ) { 109995: 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 ) ; 109997: 81 fb a0 d8 11 00 cmp $0x11d8a0,%ebx <== NOT EXECUTED 10999d: 75 ed jne 10998c <_API_extensions_Run_postdriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10999f: 5a pop %edx <== NOT EXECUTED 1099a0: 5b pop %ebx <== NOT EXECUTED 1099a1: c9 leave <== NOT EXECUTED 1099a2: c3 ret <== NOT EXECUTED 001099a3 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 1099a3: 55 push %ebp <== NOT EXECUTED 1099a4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099a6: 53 push %ebx <== NOT EXECUTED 1099a7: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1099aa: 8b 1d 9c d8 11 00 mov 0x11d89c,%ebx <== NOT EXECUTED 1099b0: eb 17 jmp 1099c9 <_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 ) 1099b2: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1099b5: 85 c0 test %eax,%eax <== NOT EXECUTED 1099b7: 74 0e je 1099c7 <_API_extensions_Run_postswitch+0x24> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 1099b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099bc: ff 35 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 1099c2: ff d0 call *%eax <== NOT EXECUTED 1099c4: 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 ) { 1099c7: 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 ) ; 1099c9: 81 fb a0 d8 11 00 cmp $0x11d8a0,%ebx <== NOT EXECUTED 1099cf: 75 e1 jne 1099b2 <_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 ); } } 1099d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1099d4: c9 leave <== NOT EXECUTED 1099d5: c3 ret <== NOT EXECUTED 00109957 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 109957: 55 push %ebp <== NOT EXECUTED 109958: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10995a: 53 push %ebx <== NOT EXECUTED 10995b: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10995e: 8b 1d 9c d8 11 00 mov 0x11d89c,%ebx <== NOT EXECUTED 109964: eb 0b jmp 109971 <_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 ) 109966: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 109969: 85 c0 test %eax,%eax <== NOT EXECUTED 10996b: 74 02 je 10996f <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED (*the_extension->predriver_hook)(); 10996d: 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 ) { 10996f: 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 ) ; 109971: 81 fb a0 d8 11 00 cmp $0x11d8a0,%ebx <== NOT EXECUTED 109977: 75 ed jne 109966 <_API_extensions_Run_predriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 109979: 58 pop %eax <== NOT EXECUTED 10997a: 5b pop %ebx <== NOT EXECUTED 10997b: c9 leave <== NOT EXECUTED 10997c: c3 ret <== NOT EXECUTED 0010d8cc <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10d8cc: 55 push %ebp <== NOT EXECUTED 10d8cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d8d2: 6a 04 push $0x4 <== NOT EXECUTED 10d8d4: 6a 00 push $0x0 <== NOT EXECUTED 10d8d6: 6a 60 push $0x60 <== NOT EXECUTED 10d8d8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d8db: 6a 0a push $0xa <== NOT EXECUTED 10d8dd: 6a 02 push $0x2 <== NOT EXECUTED 10d8df: 68 f8 df 11 00 push $0x11dff8 <== NOT EXECUTED 10d8e4: e8 0f ce ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d8e9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d8ec: c9 leave <== NOT EXECUTED 10d8ed: c3 ret <== NOT EXECUTED 0010e818 <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 10e818: 55 push %ebp <== NOT EXECUTED 10e819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e81b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e81e: 8b 04 85 78 f0 11 00 mov 0x11f078(,%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]; } 10e825: c9 leave <== NOT EXECUTED 10e826: c3 ret <== NOT EXECUTED 0010b6c0 <_CORE_RWLock_Initialize>: void _CORE_RWLock_Initialize( CORE_RWLock_Control *the_rwlock, CORE_RWLock_Attributes *the_rwlock_attributes ) { 10b6c0: 55 push %ebp <== NOT EXECUTED 10b6c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b6c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_rwlock->Attributes = *the_rwlock_attributes; 10b6c9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b6cc: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10b6ce: 89 50 40 mov %edx,0x40(%eax) <== NOT EXECUTED /* the_rwlock->number_of_waiting_threads = 0; */ the_rwlock->number_of_readers = 0; 10b6d1: c7 40 48 00 00 00 00 movl $0x0,0x48(%eax) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10b6d8: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax) <== NOT EXECUTED _Thread_queue_Initialize( 10b6df: 6a 03 push $0x3 <== NOT EXECUTED 10b6e1: 68 00 00 02 00 push $0x20000 <== NOT EXECUTED 10b6e6: 6a 00 push $0x0 <== NOT EXECUTED 10b6e8: 50 push %eax <== NOT EXECUTED 10b6e9: e8 f2 19 00 00 call 10d0e0 <_Thread_queue_Initialize> <== NOT EXECUTED 10b6ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_rwlock->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_RWLOCK, CORE_RWLOCK_TIMEOUT ); } 10b6f1: c9 leave <== NOT EXECUTED 10b6f2: c3 ret <== NOT EXECUTED 0010b6f4 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10b6f4: 55 push %ebp <== NOT EXECUTED 10b6f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6f7: 57 push %edi <== NOT EXECUTED 10b6f8: 56 push %esi <== NOT EXECUTED 10b6f9: 53 push %ebx <== NOT EXECUTED 10b6fa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b6fd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b700: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b703: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10b706: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b709: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10b70c: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10b70f: 88 45 ef mov %al,-0x11(%ebp) <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10b712: 8b 35 70 fb 11 00 mov 0x11fb70,%esi <== NOT EXECUTED * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10b718: 9c pushf <== NOT EXECUTED 10b719: fa cli <== NOT EXECUTED 10b71a: 5f pop %edi <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10b71b: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10b71e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b720: 74 05 je 10b727 <_CORE_RWLock_Obtain_for_reading+0x33> <== NOT EXECUTED 10b722: 48 dec %eax <== NOT EXECUTED 10b723: 75 2e jne 10b753 <_CORE_RWLock_Obtain_for_reading+0x5f> <== NOT EXECUTED 10b725: eb 0e jmp 10b735 <_CORE_RWLock_Obtain_for_reading+0x41> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10b727: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10b72e: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b731: 57 push %edi <== NOT EXECUTED 10b732: 9d popf <== NOT EXECUTED 10b733: eb 15 jmp 10b74a <_CORE_RWLock_Obtain_for_reading+0x56> <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10b735: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b738: 53 push %ebx <== NOT EXECUTED 10b739: e8 2e 19 00 00 call 10d06c <_Thread_queue_First> <== NOT EXECUTED if ( !waiter ) { 10b73e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b741: 85 c0 test %eax,%eax <== NOT EXECUTED 10b743: 75 0e jne 10b753 <_CORE_RWLock_Obtain_for_reading+0x5f> <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10b745: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b748: 57 push %edi <== NOT EXECUTED 10b749: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b74a: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED 10b751: eb 4d jmp 10b7a0 <_CORE_RWLock_Obtain_for_reading+0xac> <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10b753: 80 7d ef 00 cmpb $0x0,-0x11(%ebp) <== NOT EXECUTED 10b757: 75 0b jne 10b764 <_CORE_RWLock_Obtain_for_reading+0x70> <== NOT EXECUTED _ISR_Enable( level ); 10b759: 57 push %edi <== NOT EXECUTED 10b75a: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10b75b: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) <== NOT EXECUTED 10b762: eb 3c jmp 10b7a0 <_CORE_RWLock_Obtain_for_reading+0xac> <== 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 10b764: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10b76b: 89 5e 44 mov %ebx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 10b76e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b771: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10b774: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b77b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10b782: 57 push %edi <== NOT EXECUTED 10b783: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10b784: c7 45 10 c4 b8 10 00 movl $0x10b8c4,0x10(%ebp) <== NOT EXECUTED 10b78b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b78e: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10b791: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b794: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b797: 5b pop %ebx <== NOT EXECUTED 10b798: 5e pop %esi <== NOT EXECUTED 10b799: 5f pop %edi <== NOT EXECUTED 10b79a: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10b79b: e9 d0 15 00 00 jmp 10cd70 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b7a0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b7a3: 5b pop %ebx <== NOT EXECUTED 10b7a4: 5e pop %esi <== NOT EXECUTED 10b7a5: 5f pop %edi <== NOT EXECUTED 10b7a6: c9 leave <== NOT EXECUTED 10b7a7: c3 ret <== NOT EXECUTED 0010b7a8 <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10b7a8: 55 push %ebp <== NOT EXECUTED 10b7a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7ab: 57 push %edi <== NOT EXECUTED 10b7ac: 56 push %esi <== NOT EXECUTED 10b7ad: 53 push %ebx <== NOT EXECUTED 10b7ae: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7b1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b7b4: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10b7b7: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10b7ba: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10b7bf: 9c pushf <== NOT EXECUTED 10b7c0: fa cli <== NOT EXECUTED 10b7c1: 59 pop %ecx <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10b7c2: 83 7a 44 00 cmpl $0x0,0x44(%edx) <== NOT EXECUTED 10b7c6: 75 12 jne 10b7da <_CORE_RWLock_Obtain_for_writing+0x32> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10b7c8: c7 42 44 02 00 00 00 movl $0x2,0x44(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10b7cf: 51 push %ecx <== NOT EXECUTED 10b7d0: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b7d1: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 10b7d8: eb 42 jmp 10b81c <_CORE_RWLock_Obtain_for_writing+0x74> <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10b7da: 84 db test %bl,%bl <== NOT EXECUTED 10b7dc: 75 0b jne 10b7e9 <_CORE_RWLock_Obtain_for_writing+0x41> <== NOT EXECUTED _ISR_Enable( level ); 10b7de: 51 push %ecx <== NOT EXECUTED 10b7df: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10b7e0: c7 40 34 02 00 00 00 movl $0x2,0x34(%eax) <== NOT EXECUTED 10b7e7: eb 33 jmp 10b81c <_CORE_RWLock_Obtain_for_writing+0x74> <== NOT EXECUTED 10b7e9: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10b7f0: 89 50 44 mov %edx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10b7f3: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10b7f6: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b7fd: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10b804: 51 push %ecx <== NOT EXECUTED 10b805: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10b806: c7 45 10 c4 b8 10 00 movl $0x10b8c4,0x10(%ebp) <== NOT EXECUTED 10b80d: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10b810: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b813: 5b pop %ebx <== NOT EXECUTED 10b814: 5e pop %esi <== NOT EXECUTED 10b815: 5f pop %edi <== NOT EXECUTED 10b816: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10b817: e9 54 15 00 00 jmp 10cd70 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b81c: 5b pop %ebx <== NOT EXECUTED 10b81d: 5e pop %esi <== NOT EXECUTED 10b81e: 5f pop %edi <== NOT EXECUTED 10b81f: c9 leave <== NOT EXECUTED 10b820: c3 ret <== NOT EXECUTED 0010b824 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 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 10b82b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10b82e: 8b 0d 70 fb 11 00 mov 0x11fb70,%ecx <== NOT EXECUTED * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10b834: 9c pushf <== NOT EXECUTED 10b835: fa cli <== NOT EXECUTED 10b836: 5a pop %edx <== NOT EXECUTED if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10b837: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10b83a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b83c: 75 0b jne 10b849 <_CORE_RWLock_Release+0x25> <== NOT EXECUTED _ISR_Enable( level ); 10b83e: 52 push %edx <== NOT EXECUTED 10b83f: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10b840: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) <== NOT EXECUTED 10b847: eb 72 jmp 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10b849: 48 dec %eax <== NOT EXECUTED 10b84a: 75 0f jne 10b85b <_CORE_RWLock_Release+0x37> <== NOT EXECUTED the_rwlock->number_of_readers -= 1; 10b84c: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b84f: 48 dec %eax <== NOT EXECUTED 10b850: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED if ( the_rwlock->number_of_readers != 0 ) { 10b853: 85 c0 test %eax,%eax <== NOT EXECUTED 10b855: 74 04 je 10b85b <_CORE_RWLock_Release+0x37> <== NOT EXECUTED /* must be unlocked again */ _ISR_Enable( level ); 10b857: 52 push %edx <== NOT EXECUTED 10b858: 9d popf <== NOT EXECUTED 10b859: eb 60 jmp 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b85b: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10b862: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b869: 52 push %edx <== NOT EXECUTED 10b86a: 9d popf <== NOT EXECUTED next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10b86b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b86e: 53 push %ebx <== NOT EXECUTED 10b86f: e8 e4 13 00 00 call 10cc58 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( next ) { 10b874: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b877: 85 c0 test %eax,%eax <== NOT EXECUTED 10b879: 74 40 je 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10b87b: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b87f: 75 09 jne 10b88a <_CORE_RWLock_Release+0x66> <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10b881: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) <== NOT EXECUTED 10b888: eb 31 jmp 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10b88a: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10b88d: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10b894: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b897: 53 push %ebx <== NOT EXECUTED 10b898: e8 cf 17 00 00 call 10d06c <_Thread_queue_First> <== NOT EXECUTED if ( !next || 10b89d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8a2: 74 17 je 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED 10b8a4: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b8a8: 74 11 je 10b8bb <_CORE_RWLock_Release+0x97> <== NOT EXECUTED next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10b8aa: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10b8ad: 52 push %edx <== NOT EXECUTED 10b8ae: 52 push %edx <== NOT EXECUTED 10b8af: 50 push %eax <== NOT EXECUTED 10b8b0: 53 push %ebx <== NOT EXECUTED 10b8b1: e8 9e 16 00 00 call 10cf54 <_Thread_queue_Extract> <== NOT EXECUTED 10b8b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8b9: eb d9 jmp 10b894 <_CORE_RWLock_Release+0x70> <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10b8bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b8bd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b8c0: c9 leave <== NOT EXECUTED 10b8c1: c3 ret <== NOT EXECUTED 0010b8c4 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10b8c4: 55 push %ebp <== NOT EXECUTED 10b8c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b8c7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b8ca: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b8cd: 50 push %eax <== NOT EXECUTED 10b8ce: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b8d1: e8 6a 10 00 00 call 10c940 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b8d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8d9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b8dd: 75 17 jne 10b8f6 <_CORE_RWLock_Timeout+0x32> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10b8df: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b8e2: 50 push %eax <== NOT EXECUTED 10b8e3: e8 74 18 00 00 call 10d15c <_Thread_queue_Process_timeout> <== NOT EXECUTED 10b8e8: a1 b0 fa 11 00 mov 0x11fab0,%eax <== NOT EXECUTED 10b8ed: 48 dec %eax <== NOT EXECUTED 10b8ee: a3 b0 fa 11 00 mov %eax,0x11fab0 <== NOT EXECUTED 10b8f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10b8f6: c9 leave <== NOT EXECUTED 10b8f7: c3 ret <== NOT EXECUTED 0010a9d4 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10a9d4: 55 push %ebp <== NOT EXECUTED 10a9d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a9d7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a9da: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a9dd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10a9e0: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10a9e2: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a9e5: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10a9e8: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10a9eb: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10a9f2: 6a 03 push $0x3 <== NOT EXECUTED 10a9f4: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10a9f9: 6a 00 push $0x0 <== NOT EXECUTED 10a9fb: 52 push %edx <== NOT EXECUTED 10a9fc: e8 5f 1a 00 00 call 10c460 <_Thread_queue_Initialize> <== NOT EXECUTED 10aa01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10aa04: c9 leave <== NOT EXECUTED 10aa05: c3 ret <== NOT EXECUTED 0010ece0 <_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 ) { 10ece0: 55 push %ebp <== NOT EXECUTED 10ece1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ece3: 56 push %esi <== NOT EXECUTED 10ece4: 53 push %ebx <== NOT EXECUTED 10ece5: 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)) ) { 10ece8: 31 db xor %ebx,%ebx <== NOT EXECUTED 10ecea: eb 01 jmp 10eced <_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++; 10ecec: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10eced: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ecf0: 56 push %esi <== NOT EXECUTED 10ecf1: e8 1e d4 ff ff call 10c114 <_Thread_queue_Dequeue> <== NOT EXECUTED 10ecf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ecf9: 85 c0 test %eax,%eax <== NOT EXECUTED 10ecfb: 75 ef jne 10ecec <_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; 10ecfd: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 10ed04: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ed06: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ed09: 5b pop %ebx <== NOT EXECUTED 10ed0a: 5e pop %esi <== NOT EXECUTED 10ed0b: c9 leave <== NOT EXECUTED 10ed0c: c3 ret <== NOT EXECUTED 0010aa08 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10aa08: 55 push %ebp <== NOT EXECUTED 10aa09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa0b: 57 push %edi <== NOT EXECUTED 10aa0c: 56 push %esi <== NOT EXECUTED 10aa0d: 53 push %ebx <== NOT EXECUTED 10aa0e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aa11: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10aa14: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aa17: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10aa1a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10aa1d: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10aa20: 8b 0d 10 ec 11 00 mov 0x11ec10,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10aa26: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10aa2d: 9c pushf <== NOT EXECUTED 10aa2e: fa cli <== NOT EXECUTED 10aa2f: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10aa30: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10aa33: 40 inc %eax <== NOT EXECUTED 10aa34: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10aa37: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10aa3a: 75 22 jne 10aa5e <_CORE_barrier_Wait+0x56> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10aa3c: 83 7a 40 00 cmpl $0x0,0x40(%edx) <== NOT EXECUTED 10aa40: 75 1c jne 10aa5e <_CORE_barrier_Wait+0x56> <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 10aa42: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10aa49: 53 push %ebx <== NOT EXECUTED 10aa4a: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10aa4b: 89 7d 10 mov %edi,0x10(%ebp) <== NOT EXECUTED 10aa4e: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10aa51: 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 ); } 10aa54: 5a pop %edx <== NOT EXECUTED 10aa55: 5b pop %ebx <== NOT EXECUTED 10aa56: 5e pop %esi <== NOT EXECUTED 10aa57: 5f pop %edi <== NOT EXECUTED 10aa58: 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 ); 10aa59: e9 82 42 00 00 jmp 10ece0 <_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 10aa5e: 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; 10aa65: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10aa68: 89 71 20 mov %esi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10aa6b: 53 push %ebx <== NOT EXECUTED 10aa6c: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10aa6d: c7 45 10 30 c5 10 00 movl $0x10c530,0x10(%ebp) <== NOT EXECUTED 10aa74: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10aa77: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10aa7a: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10aa7d: 58 pop %eax <== NOT EXECUTED 10aa7e: 5b pop %ebx <== NOT EXECUTED 10aa7f: 5e pop %esi <== NOT EXECUTED 10aa80: 5f pop %edi <== NOT EXECUTED 10aa81: 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 ); 10aa82: e9 a5 17 00 00 jmp 10c22c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00113adc <_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 ) { 113adc: 55 push %ebp <== NOT EXECUTED 113add: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113adf: 57 push %edi <== NOT EXECUTED 113ae0: 56 push %esi <== NOT EXECUTED 113ae1: 53 push %ebx <== NOT EXECUTED 113ae2: 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 ) { 113ae5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 113aea: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113aed: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 113af0: 3b 4a 4c cmp 0x4c(%edx),%ecx <== NOT EXECUTED 113af3: 77 43 ja 113b38 <_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))) { 113af5: 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 ) { 113af7: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 113afa: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 113afe: 74 21 je 113b21 <_CORE_message_queue_Broadcast+0x45> <== NOT EXECUTED *count = 0; 113b00: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 113b03: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 113b09: 31 c0 xor %eax,%eax <== NOT EXECUTED 113b0b: eb 2b jmp 113b38 <_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; 113b0d: 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 113b0e: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 113b11: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 113b14: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113b17: 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; 113b19: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 113b1c: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 113b1f: 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))) { 113b21: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113b24: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113b27: e8 98 1f 00 00 call 115ac4 <_Thread_queue_Dequeue> <== NOT EXECUTED 113b2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113b2f: 85 c0 test %eax,%eax <== NOT EXECUTED 113b31: 75 da jne 113b0d <_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; 113b33: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 113b36: 89 19 mov %ebx,(%ecx) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 113b38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113b3b: 5b pop %ebx <== NOT EXECUTED 113b3c: 5e pop %esi <== NOT EXECUTED 113b3d: 5f pop %edi <== NOT EXECUTED 113b3e: c9 leave <== NOT EXECUTED 113b3f: c3 ret <== NOT EXECUTED 00112fb0 <_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 ) { 112fb0: 55 push %ebp <== NOT EXECUTED 112fb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112fb3: 53 push %ebx <== NOT EXECUTED 112fb4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112fb7: 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( 112fba: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112fbd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112fc0: 53 push %ebx <== NOT EXECUTED 112fc1: e8 8a bb ff ff call 10eb50 <_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 ) 112fc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112fc9: 83 7b 48 00 cmpl $0x0,0x48(%ebx) <== NOT EXECUTED 112fcd: 74 0c je 112fdb <_CORE_message_queue_Close+0x2b> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 112fcf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112fd2: 53 push %ebx <== NOT EXECUTED 112fd3: e8 14 00 00 00 call 112fec <_CORE_message_queue_Flush_support> <== NOT EXECUTED 112fd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 112fdb: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 112fde: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 112fe1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112fe4: 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 ); 112fe5: e9 1e c5 ff ff jmp 10f508 <_Workspace_Free> <== NOT EXECUTED 00113b7c <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 113b7c: 55 push %ebp <== NOT EXECUTED 113b7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113b7f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 113b82: 83 78 48 00 cmpl $0x0,0x48(%eax) <== NOT EXECUTED 113b86: 75 04 jne 113b8c <_CORE_message_queue_Flush+0x10> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 113b88: 31 c0 xor %eax,%eax <== NOT EXECUTED 113b8a: c9 leave <== NOT EXECUTED 113b8b: 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 ); 113b8c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 113b8f: 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 ); 113b90: e9 03 00 00 00 jmp 113b98 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00112fec <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 112fec: 55 push %ebp <== NOT EXECUTED 112fed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112fef: 56 push %esi <== NOT EXECUTED 112ff0: 53 push %ebx <== NOT EXECUTED 112ff1: 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 ); 112ff4: 9c pushf <== NOT EXECUTED 112ff5: fa cli <== NOT EXECUTED 112ff6: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 112ff7: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 112ffa: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 112ffd: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 113000: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 113003: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 113005: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 113008: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 11300b: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 11300e: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 113011: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 113014: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 11301b: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 11301e: 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; 113021: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 113024: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 11302b: 56 push %esi <== NOT EXECUTED 11302c: 9d popf <== NOT EXECUTED return count; } 11302d: 5b pop %ebx <== NOT EXECUTED 11302e: 5e pop %esi <== NOT EXECUTED 11302f: c9 leave <== NOT EXECUTED 113030: c3 ret <== NOT EXECUTED 0010e2bc <_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 ) { 10e2bc: 55 push %ebp <== NOT EXECUTED 10e2bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e2bf: 57 push %edi <== NOT EXECUTED 10e2c0: 56 push %esi <== NOT EXECUTED 10e2c1: 53 push %ebx <== NOT EXECUTED 10e2c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e2c5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e2c8: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10e2cb: 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; 10e2ce: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10e2d1: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10e2d8: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10e2db: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10e2e2: 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)) { 10e2e9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e2eb: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10e2ee: 74 0a je 10e2fa <_CORE_message_queue_Initialize+0x3e> <== NOT EXECUTED allocated_message_size += sizeof(uint32_t); 10e2f0: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10e2f3: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10e2f6: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10e2f8: 72 5f jb 10e359 <_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 * 10e2fa: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10e2fd: 89 f2 mov %esi,%edx <== NOT EXECUTED 10e2ff: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10e302: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10e304: 72 53 jb 10e359 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10e306: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e309: 52 push %edx <== NOT EXECUTED 10e30a: e8 6e 26 00 00 call 11097d <_Workspace_Allocate> <== NOT EXECUTED 10e30f: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10e312: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e315: 85 c0 test %eax,%eax <== NOT EXECUTED 10e317: 74 40 je 10e359 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10e319: 56 push %esi <== NOT EXECUTED 10e31a: 57 push %edi <== NOT EXECUTED 10e31b: 50 push %eax <== NOT EXECUTED 10e31c: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10e31f: 50 push %eax <== NOT EXECUTED 10e320: e8 5b 3a 01 00 call 121d80 <_Chain_Initialize> <== NOT EXECUTED 10e325: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10e328: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e32b: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10e332: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10e335: 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( 10e338: 6a 06 push $0x6 <== NOT EXECUTED 10e33a: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10e33f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e342: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10e345: 0f 94 c0 sete %al <== NOT EXECUTED 10e348: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10e34b: 50 push %eax <== NOT EXECUTED 10e34c: 53 push %ebx <== NOT EXECUTED 10e34d: e8 12 1d 00 00 call 110064 <_Thread_queue_Initialize> <== NOT EXECUTED 10e352: b0 01 mov $0x1,%al <== NOT EXECUTED 10e354: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e357: eb 02 jmp 10e35b <_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; 10e359: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10e35b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e35e: 5b pop %ebx <== NOT EXECUTED 10e35f: 5e pop %esi <== NOT EXECUTED 10e360: 5f pop %edi <== NOT EXECUTED 10e361: c9 leave <== NOT EXECUTED 10e362: c3 ret <== NOT EXECUTED 0010dd24 <_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 ) { 10dd24: 55 push %ebp <== NOT EXECUTED 10dd25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd27: 57 push %edi <== NOT EXECUTED 10dd28: 56 push %esi <== NOT EXECUTED 10dd29: 53 push %ebx <== NOT EXECUTED 10dd2a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dd2d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10dd30: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dd33: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10dd36: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED switch ( submit_type ) { 10dd39: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10dd3e: 74 33 je 10dd73 <_CORE_message_queue_Insert_message+0x4f> <== NOT EXECUTED 10dd40: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10dd45: 8d 53 54 lea 0x54(%ebx),%edx <== NOT EXECUTED 10dd48: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 10dd4b: 75 4d jne 10dd9a <_CORE_message_queue_Insert_message+0x76> <== NOT EXECUTED case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10dd4d: 9c pushf <== NOT EXECUTED 10dd4e: fa cli <== NOT EXECUTED 10dd4f: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10dd50: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10dd53: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10dd56: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10dd59: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd5b: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10dd5f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10dd62: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10dd64: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10dd67: 89 73 58 mov %esi,0x58(%ebx) <== NOT EXECUTED 10dd6a: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10dd6c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10dd6f: 51 push %ecx <== NOT EXECUTED 10dd70: 9d popf <== NOT EXECUTED 10dd71: eb 5b jmp 10ddce <_CORE_message_queue_Insert_message+0xaa> <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10dd73: 9c pushf <== NOT EXECUTED 10dd74: fa cli <== NOT EXECUTED 10dd75: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10dd76: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10dd79: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10dd7c: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10dd7f: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd81: 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 10dd85: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10dd88: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10dd8b: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10dd8e: 89 73 50 mov %esi,0x50(%ebx) <== NOT EXECUTED 10dd91: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10dd93: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10dd96: 51 push %ecx <== NOT EXECUTED 10dd97: 9d popf <== NOT EXECUTED 10dd98: eb 34 jmp 10ddce <_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; 10dd9a: 8b 7b 50 mov 0x50(%ebx),%edi <== NOT EXECUTED 10dd9d: eb 07 jmp 10dda6 <_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 ) { 10dd9f: 39 47 08 cmp %eax,0x8(%edi) <== NOT EXECUTED 10dda2: 7f 07 jg 10ddab <_CORE_message_queue_Insert_message+0x87> <== NOT EXECUTED the_node = the_node->next; 10dda4: 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 ) ) { 10dda6: 3b 7d ec cmp -0x14(%ebp),%edi <== NOT EXECUTED 10dda9: 75 f4 jne 10dd9f <_CORE_message_queue_Insert_message+0x7b> <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10ddab: 9c pushf <== NOT EXECUTED 10ddac: fa cli <== NOT EXECUTED 10ddad: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10ddae: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10ddb1: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10ddb4: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10ddb7: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddb9: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10ddbd: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10ddc0: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10ddc3: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ddc5: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10ddc7: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10ddc9: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10ddcc: 51 push %ecx <== NOT EXECUTED 10ddcd: 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 ) 10ddce: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10ddd2: 74 15 je 10dde9 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED 10ddd4: 8b 4b 60 mov 0x60(%ebx),%ecx <== NOT EXECUTED 10ddd7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ddd9: 74 0e je 10dde9 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10dddb: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 10ddde: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10dde1: 5b pop %ebx <== NOT EXECUTED 10dde2: 5e pop %esi <== NOT EXECUTED 10dde3: 5b pop %ebx <== NOT EXECUTED 10dde4: 5e pop %esi <== NOT EXECUTED 10dde5: 5f pop %edi <== NOT EXECUTED 10dde6: 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 ); 10dde7: ff e1 jmp *%ecx <== NOT EXECUTED } 10dde9: 58 pop %eax <== NOT EXECUTED 10ddea: 5a pop %edx <== NOT EXECUTED 10ddeb: 5b pop %ebx <== NOT EXECUTED 10ddec: 5e pop %esi <== NOT EXECUTED 10dded: 5f pop %edi <== NOT EXECUTED 10ddee: c9 leave <== NOT EXECUTED 10ddef: c3 ret <== NOT EXECUTED 00113100 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 113100: 55 push %ebp <== NOT EXECUTED 113101: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113103: 57 push %edi <== NOT EXECUTED 113104: 56 push %esi <== NOT EXECUTED 113105: 53 push %ebx <== NOT EXECUTED 113106: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 113109: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11310c: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 11310f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 113112: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 113115: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 113118: 89 7d e8 mov %edi,-0x18(%ebp) <== NOT EXECUTED 11311b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11311e: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 113121: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 113124: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 113127: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 11312a: 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; 11312d: 8b 35 1c 9a 12 00 mov 0x129a1c,%esi <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 113133: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Disable( level ); 11313a: 9c pushf <== NOT EXECUTED 11313b: fa cli <== NOT EXECUTED 11313c: 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( 11313d: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 113140: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 113143: 89 d0 mov %edx,%eax <== NOT EXECUTED 113145: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 113148: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11314a: 0f 84 9e 00 00 00 je 1131ee <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED 113150: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 113152: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 113155: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 113158: 89 f8 mov %edi,%eax <== NOT EXECUTED 11315a: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 11315d: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 113160: 85 db test %ebx,%ebx <== NOT EXECUTED 113162: 0f 84 86 00 00 00 je 1131ee <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED the_message_queue->number_of_pending_messages -= 1; 113168: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 11316b: 51 push %ecx <== NOT EXECUTED 11316c: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 11316d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 113170: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 113173: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 113175: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 113178: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 11317d: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 113180: 8d 7b 10 lea 0x10(%ebx),%edi <== NOT EXECUTED 113183: 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 113186: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 113189: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 11318b: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 11318e: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 113191: 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 ); 113193: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113196: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 113199: e8 8e b6 ff ff call 10e82c <_Thread_queue_Dequeue> <== NOT EXECUTED 11319e: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 1131a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131a3: 85 c0 test %eax,%eax <== NOT EXECUTED 1131a5: 75 18 jne 1131bf <_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 1131a7: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1131aa: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 1131ad: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 1131b0: 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 ); } 1131b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1131b6: 5b pop %ebx <== NOT EXECUTED 1131b7: 5e pop %esi <== NOT EXECUTED 1131b8: 5f pop %edi <== NOT EXECUTED 1131b9: c9 leave <== NOT EXECUTED 1131ba: e9 69 9f ff ff jmp 10d128 <_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; 1131bf: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1131c2: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 1131c5: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 1131c8: 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 1131cb: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 1131ce: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 1131d1: 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( 1131d3: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1131d6: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1131d9: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1131dc: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 1131df: 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 ); } 1131e2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1131e5: 5b pop %ebx <== NOT EXECUTED 1131e6: 5e pop %esi <== NOT EXECUTED 1131e7: 5f pop %edi <== NOT EXECUTED 1131e8: 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( 1131e9: e9 46 fe ff ff jmp 113034 <_CORE_message_queue_Insert_message> <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 1131ee: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) <== NOT EXECUTED 1131f2: 75 11 jne 113205 <_CORE_message_queue_Seize+0x105> <== NOT EXECUTED _ISR_Enable( level ); 1131f4: 51 push %ecx <== NOT EXECUTED 1131f5: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1131f6: 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 ); } 1131fd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113200: 5b pop %ebx <== NOT EXECUTED 113201: 5e pop %esi <== NOT EXECUTED 113202: 5f pop %edi <== NOT EXECUTED 113203: c9 leave <== NOT EXECUTED 113204: 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 113205: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 113208: 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; 11320f: 89 56 44 mov %edx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 113212: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 113215: 89 7e 20 mov %edi,0x20(%esi) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 113218: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11321b: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED executing->Wait.return_argument = size_p; 11321e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 113221: 89 56 28 mov %edx,0x28(%esi) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 113224: 51 push %ecx <== NOT EXECUTED 113225: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 113226: c7 45 10 48 ec 10 00 movl $0x10ec48,0x10(%ebp) <== NOT EXECUTED 11322d: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 113230: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 113233: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 113236: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 113239: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11323c: 5b pop %ebx <== NOT EXECUTED 11323d: 5e pop %esi <== NOT EXECUTED 11323e: 5f pop %edi <== NOT EXECUTED 11323f: 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 ); 113240: e9 ff b6 ff ff jmp 10e944 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00109b0c <_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 ) { 109b0c: 55 push %ebp <== NOT EXECUTED 109b0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b0f: 57 push %edi <== NOT EXECUTED 109b10: 56 push %esi <== NOT EXECUTED 109b11: 53 push %ebx <== NOT EXECUTED 109b12: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109b15: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 109b18: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 109b1b: 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 ) { 109b1e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 109b23: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109b26: 3b 5a 4c cmp 0x4c(%edx),%ebx <== NOT EXECUTED 109b29: 0f 87 d9 00 00 00 ja 109c08 <_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 ) { 109b2f: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109b32: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 109b36: 75 2e jne 109b66 <_CORE_message_queue_Submit+0x5a> <== NOT EXECUTED the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 109b38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b3b: 56 push %esi <== NOT EXECUTED 109b3c: e8 57 16 00 00 call 10b198 <_Thread_queue_Dequeue> <== NOT EXECUTED 109b41: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 109b43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b46: 85 c0 test %eax,%eax <== NOT EXECUTED 109b48: 74 1c je 109b66 <_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 109b4a: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 109b4d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109b50: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109b52: 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; 109b54: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 109b57: 89 18 mov %ebx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 109b59: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 109b5c: 89 42 24 mov %eax,0x24(%edx) <== NOT EXECUTED 109b5f: 31 c0 xor %eax,%eax <== NOT EXECUTED 109b61: e9 a2 00 00 00 jmp 109c08 <_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 < 109b66: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109b69: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 109b6c: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 109b6f: 73 37 jae 109ba8 <_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. 109b71: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b74: 89 d0 mov %edx,%eax <== NOT EXECUTED 109b76: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 109b79: 50 push %eax <== NOT EXECUTED 109b7a: e8 65 ff ff ff call 109ae4 <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 109b7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b82: 85 c0 test %eax,%eax <== NOT EXECUTED 109b84: 74 7d je 109c03 <_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 109b86: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 109b89: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109b8c: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109b8e: 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; 109b90: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 109b93: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 109b96: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 109b99: 51 push %ecx <== NOT EXECUTED 109b9a: 52 push %edx <== NOT EXECUTED 109b9b: 50 push %eax <== NOT EXECUTED 109b9c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109b9f: e8 80 41 00 00 call 10dd24 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 109ba4: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ba6: eb 56 jmp 109bfe <_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 ) { 109ba8: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109bad: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 109bb1: 74 55 je 109c08 <_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() ) { 109bb3: a1 14 d7 11 00 mov 0x11d714,%eax <== NOT EXECUTED 109bb8: 85 c0 test %eax,%eax <== NOT EXECUTED 109bba: 75 47 jne 109c03 <_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; 109bbc: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED _ISR_Disable( level ); 109bc1: 9c pushf <== NOT EXECUTED 109bc2: fa cli <== NOT EXECUTED 109bc3: 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 109bc4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109bc7: 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; 109bce: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 109bd1: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 109bd4: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 109bd7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 109bda: 89 50 2c mov %edx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 109bdd: 89 58 30 mov %ebx,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 109be0: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 109be3: 89 70 24 mov %esi,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 109be6: 51 push %ecx <== NOT EXECUTED 109be7: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 109be8: 50 push %eax <== NOT EXECUTED 109be9: 68 b4 b5 10 00 push $0x10b5b4 <== NOT EXECUTED 109bee: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 109bf1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109bf4: e8 b7 16 00 00 call 10b2b0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 109bf9: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 109bfe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c01: eb 05 jmp 109c08 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 109c03: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 109c08: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109c0b: 5b pop %ebx <== NOT EXECUTED 109c0c: 5e pop %esi <== NOT EXECUTED 109c0d: 5f pop %edi <== NOT EXECUTED 109c0e: c9 leave <== NOT EXECUTED 109c0f: c3 ret <== NOT EXECUTED 00109c10 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109c10: 55 push %ebp <== NOT EXECUTED 109c11: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 109c13: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109c14: e9 a3 18 00 00 jmp 10b4bc <_Thread_queue_Flush> <== NOT EXECUTED 00109c1c <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 109c1c: 55 push %ebp <== NOT EXECUTED 109c1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c1f: 57 push %edi <== NOT EXECUTED 109c20: 56 push %esi <== NOT EXECUTED 109c21: 53 push %ebx <== NOT EXECUTED 109c22: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c25: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109c28: 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; 109c2b: 8d 7b 40 lea 0x40(%ebx),%edi <== NOT EXECUTED 109c2e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109c33: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109c36: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 109c38: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_mutex->blocked_count = 0; 109c3b: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 109c42: 85 c0 test %eax,%eax <== NOT EXECUTED 109c44: 75 35 jne 109c7b <_CORE_mutex_Initialize+0x5f> <== NOT EXECUTED the_mutex->nest_count = 1; 109c46: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 109c4d: 8b 15 38 d7 11 00 mov 0x11d738,%edx <== NOT EXECUTED 109c53: 89 53 5c mov %edx,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 109c56: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 109c59: 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 109c5c: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109c5f: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109c62: 74 05 je 109c69 <_CORE_mutex_Initialize+0x4d> <== NOT EXECUTED 109c64: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109c67: 75 27 jne 109c90 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 109c69: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 109c6c: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 109c71: 3b 43 4c cmp 0x4c(%ebx),%eax <== NOT EXECUTED 109c74: 72 3a jb 109cb0 <_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++; 109c76: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109c79: eb 15 jmp 109c90 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 109c7b: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = NULL; 109c82: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109c89: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED } _Thread_queue_Initialize( 109c90: 6a 05 push $0x5 <== NOT EXECUTED 109c92: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 109c97: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109c9a: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED 109c9e: 0f 95 c0 setne %al <== NOT EXECUTED 109ca1: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109ca4: 50 push %eax <== NOT EXECUTED 109ca5: 53 push %ebx <== NOT EXECUTED 109ca6: e8 39 18 00 00 call 10b4e4 <_Thread_queue_Initialize> <== NOT EXECUTED 109cab: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 109cad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 109cb0: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109cb2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109cb5: 5b pop %ebx <== NOT EXECUTED 109cb6: 5e pop %esi <== NOT EXECUTED 109cb7: 5f pop %edi <== NOT EXECUTED 109cb8: c9 leave <== NOT EXECUTED 109cb9: c3 ret <== NOT EXECUTED 00109d08 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 109d08: 55 push %ebp <== NOT EXECUTED 109d09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d0b: 56 push %esi <== NOT EXECUTED 109d0c: 53 push %ebx <== NOT EXECUTED 109d0d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109d10: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 109d13: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 109d18: 85 c0 test %eax,%eax <== NOT EXECUTED 109d1a: 74 19 je 109d35 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109d1c: 84 db test %bl,%bl <== NOT EXECUTED 109d1e: 74 15 je 109d35 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109d20: 83 3d 18 d8 11 00 01 cmpl $0x1,0x11d818 <== NOT EXECUTED 109d27: 76 0c jbe 109d35 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109d29: 50 push %eax <== NOT EXECUTED 109d2a: 6a 13 push $0x13 <== NOT EXECUTED 109d2c: 6a 00 push $0x0 <== NOT EXECUTED 109d2e: 6a 00 push $0x0 <== NOT EXECUTED 109d30: e8 93 04 00 00 call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED 109d35: 50 push %eax <== NOT EXECUTED 109d36: 50 push %eax <== NOT EXECUTED 109d37: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 109d3a: 50 push %eax <== NOT EXECUTED 109d3b: 56 push %esi <== NOT EXECUTED 109d3c: e8 af 40 00 00 call 10ddf0 <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 109d41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d44: 85 c0 test %eax,%eax <== NOT EXECUTED 109d46: 74 49 je 109d91 <_CORE_mutex_Seize+0x89> <== NOT EXECUTED 109d48: 84 db test %bl,%bl <== NOT EXECUTED 109d4a: 75 12 jne 109d5e <_CORE_mutex_Seize+0x56> <== NOT EXECUTED 109d4c: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109d4f: 9d popf <== NOT EXECUTED 109d50: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED 109d55: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED 109d5c: eb 33 jmp 109d91 <_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 109d5e: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 109d65: 8b 15 38 d7 11 00 mov 0x11d738,%edx <== NOT EXECUTED 109d6b: 89 72 44 mov %esi,0x44(%edx) <== NOT EXECUTED 109d6e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109d71: 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 109d74: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 109d79: 40 inc %eax <== NOT EXECUTED 109d7a: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED 109d7f: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109d82: 9d popf <== NOT EXECUTED 109d83: 53 push %ebx <== NOT EXECUTED 109d84: 53 push %ebx <== NOT EXECUTED 109d85: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 109d88: 56 push %esi <== NOT EXECUTED 109d89: e8 2e ff ff ff call 109cbc <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 109d8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d91: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109d94: 5b pop %ebx <== NOT EXECUTED 109d95: 5e pop %esi <== NOT EXECUTED 109d96: c9 leave <== NOT EXECUTED 109d97: c3 ret <== NOT EXECUTED 00109cbc <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 109cbc: 55 push %ebp <== NOT EXECUTED 109cbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cbf: 56 push %esi <== NOT EXECUTED 109cc0: 53 push %ebx <== NOT EXECUTED 109cc1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109cc4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 109cc7: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 109ccc: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 109cd0: 75 18 jne 109cea <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED if ( the_mutex->holder->current_priority > executing->current_priority ) { 109cd2: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 109cd5: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 109cd8: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 109cdb: 76 0d jbe 109cea <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED _Thread_Change_priority( 109cdd: 51 push %ecx <== NOT EXECUTED 109cde: 6a 00 push $0x0 <== NOT EXECUTED 109ce0: 50 push %eax <== NOT EXECUTED 109ce1: 52 push %edx <== NOT EXECUTED 109ce2: e8 d9 0c 00 00 call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED 109ce7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 109cea: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 109ced: 50 push %eax <== NOT EXECUTED 109cee: 68 b4 b5 10 00 push $0x10b5b4 <== NOT EXECUTED 109cf3: 56 push %esi <== NOT EXECUTED 109cf4: 53 push %ebx <== NOT EXECUTED 109cf5: e8 b6 15 00 00 call 10b2b0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 109cfa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109cfd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109d00: 5b pop %ebx <== NOT EXECUTED 109d01: 5e pop %esi <== NOT EXECUTED 109d02: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 109d03: e9 58 11 00 00 jmp 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010ddf0 <_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 ) { 10ddf0: 55 push %ebp <== NOT EXECUTED 10ddf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddf3: 56 push %esi <== NOT EXECUTED 10ddf4: 53 push %ebx <== NOT EXECUTED 10ddf5: 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 ); 10ddf8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ddfb: 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. * 10ddfd: 8b 15 38 d7 11 00 mov 0x11d738,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10de03: 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 10de0a: 83 79 50 00 cmpl $0x0,0x50(%ecx) <== NOT EXECUTED 10de0e: 0f 84 82 00 00 00 je 10de96 <_CORE_mutex_Seize_interrupt_trylock+0xa6> <== NOT EXECUTED * to be resized 10de14: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10de1b: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10de1e: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10de21: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10de24: 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 10de2b: 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. 10de2e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10de31: 74 05 je 10de38 <_CORE_mutex_Seize_interrupt_trylock+0x48> <== NOT EXECUTED 10de33: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10de36: 75 03 jne 10de3b <_CORE_mutex_Seize_interrupt_trylock+0x4b> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10de38: 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. * 10de3b: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10de3f: 74 04 je 10de45 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10de41: 56 push %esi <== NOT EXECUTED 10de42: 9d popf <== NOT EXECUTED 10de43: eb 74 jmp 10deb9 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10de45: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10de48: 3b 41 4c cmp 0x4c(%ecx),%eax <== NOT EXECUTED 10de4b: 75 04 jne 10de51 <_CORE_mutex_Seize_interrupt_trylock+0x61> <== NOT EXECUTED * @param[in] source is a user specified integer which may be used to 10de4d: 56 push %esi <== NOT EXECUTED 10de4e: 9d popf <== NOT EXECUTED 10de4f: eb 68 jmp 10deb9 <_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. */ 10de51: 76 27 jbe 10de7a <_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 10de53: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10de58: 40 inc %eax <== NOT EXECUTED 10de59: a3 78 d6 11 00 mov %eax,0x11d678 <== 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, 10de5e: 56 push %esi <== NOT EXECUTED 10de5f: 9d popf <== NOT EXECUTED int source, 10de60: 50 push %eax <== NOT EXECUTED 10de61: 6a 00 push $0x0 <== NOT EXECUTED 10de63: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10de66: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10de69: e8 52 cb ff ff call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10de6e: e8 ed cf ff ff call 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED 10de73: 31 c0 xor %eax,%eax <== NOT EXECUTED 10de75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de78: eb 48 jmp 10dec2 <_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 10de7a: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10de81: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10de88: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10de8f: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10de92: 56 push %esi <== NOT EXECUTED 10de93: 9d popf <== NOT EXECUTED 10de94: eb 23 jmp 10deb9 <_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. 10de96: 8b 59 5c mov 0x5c(%ecx),%ebx <== NOT EXECUTED 10de99: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10de9b: 75 20 jne 10debd <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED */ 10de9d: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10dea0: 85 c0 test %eax,%eax <== NOT EXECUTED 10dea2: 74 05 je 10dea9 <_CORE_mutex_Seize_interrupt_trylock+0xb9> <== NOT EXECUTED 10dea4: 48 dec %eax <== NOT EXECUTED 10dea5: 75 16 jne 10debd <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED 10dea7: eb 07 jmp 10deb0 <_CORE_mutex_Seize_interrupt_trylock+0xc0> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10dea9: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10deac: 56 push %esi <== NOT EXECUTED 10dead: 9d popf <== NOT EXECUTED 10deae: eb 09 jmp 10deb9 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED ); #ifdef __cplusplus 10deb0: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx) <== NOT EXECUTED } 10deb7: 56 push %esi <== NOT EXECUTED 10deb8: 9d popf <== NOT EXECUTED 10deb9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10debb: eb 05 jmp 10dec2 <_CORE_mutex_Seize_interrupt_trylock+0xd2> <== NOT EXECUTED 10debd: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10dec2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dec5: 5b pop %ebx <== NOT EXECUTED 10dec6: 5e pop %esi <== NOT EXECUTED 10dec7: c9 leave <== NOT EXECUTED 10dec8: c3 ret <== NOT EXECUTED 00109d98 <_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 ) { 109d98: 55 push %ebp <== NOT EXECUTED 109d99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d9b: 53 push %ebx <== NOT EXECUTED 109d9c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109d9f: 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; 109da2: 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 ) { 109da5: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 109da9: 74 11 je 109dbc <_CORE_mutex_Surrender+0x24> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 109dab: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109db0: 3b 0d 38 d7 11 00 cmp 0x11d738,%ecx <== NOT EXECUTED 109db6: 0f 85 cb 00 00 00 jne 109e87 <_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 ) 109dbc: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 109dbf: 85 c0 test %eax,%eax <== NOT EXECUTED 109dc1: 0f 84 be 00 00 00 je 109e85 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 109dc7: 48 dec %eax <== NOT EXECUTED 109dc8: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 109dcb: 85 c0 test %eax,%eax <== NOT EXECUTED 109dcd: 74 17 je 109de6 <_CORE_mutex_Surrender+0x4e> <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 109dcf: 8b 53 40 mov 0x40(%ebx),%edx <== NOT EXECUTED 109dd2: 85 d2 test %edx,%edx <== NOT EXECUTED 109dd4: 0f 84 ab 00 00 00 je 109e85 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109dda: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109ddf: 4a dec %edx <== NOT EXECUTED 109de0: 0f 84 a1 00 00 00 je 109e87 <_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 109de6: 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 ) || 109de9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109dec: 74 05 je 109df3 <_CORE_mutex_Surrender+0x5b> <== NOT EXECUTED 109dee: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109df1: 75 03 jne 109df6 <_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--; 109df3: ff 49 1c decl 0x1c(%ecx) <== NOT EXECUTED } the_mutex->holder = NULL; 109df6: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109dfd: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 109e04: 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 ) || 109e07: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109e0a: 74 05 je 109e11 <_CORE_mutex_Surrender+0x79> <== NOT EXECUTED 109e0c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109e0f: 75 1b jne 109e2c <_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 && 109e11: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 109e15: 75 15 jne 109e2c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED 109e17: 8b 41 18 mov 0x18(%ecx),%eax <== NOT EXECUTED 109e1a: 3b 41 14 cmp 0x14(%ecx),%eax <== NOT EXECUTED 109e1d: 74 0d je 109e2c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 109e1f: 52 push %edx <== NOT EXECUTED 109e20: 6a 01 push $0x1 <== NOT EXECUTED 109e22: 50 push %eax <== NOT EXECUTED 109e23: 51 push %ecx <== NOT EXECUTED 109e24: e8 97 0b 00 00 call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED 109e29: 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 ) ) ) { 109e2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109e2f: 53 push %ebx <== NOT EXECUTED 109e30: e8 63 13 00 00 call 10b198 <_Thread_queue_Dequeue> <== NOT EXECUTED 109e35: 89 c2 mov %eax,%edx <== NOT EXECUTED 109e37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e3a: 85 c0 test %eax,%eax <== NOT EXECUTED 109e3c: 74 40 je 109e7e <_CORE_mutex_Surrender+0xe6> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 109e3e: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 109e41: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109e44: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 109e47: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 109e4e: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109e51: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109e54: 74 07 je 109e5d <_CORE_mutex_Surrender+0xc5> <== NOT EXECUTED 109e56: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109e59: 75 2a jne 109e85 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109e5b: eb 05 jmp 109e62 <_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++; 109e5d: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109e60: eb 23 jmp 109e85 <_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++; 109e62: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 109e65: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 109e68: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 109e6b: 73 18 jae 109e85 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 109e6d: 51 push %ecx <== NOT EXECUTED 109e6e: 6a 00 push $0x0 <== NOT EXECUTED 109e70: 50 push %eax <== NOT EXECUTED 109e71: 52 push %edx <== NOT EXECUTED 109e72: e8 49 0b 00 00 call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED 109e77: 31 c0 xor %eax,%eax <== NOT EXECUTED 109e79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e7c: eb 09 jmp 109e87 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 109e7e: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 109e85: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 109e87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e8a: c9 leave <== NOT EXECUTED 109e8b: c3 ret <== NOT EXECUTED 00109e8c <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109e8c: 55 push %ebp <== NOT EXECUTED 109e8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 109e8f: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109e90: e9 27 16 00 00 jmp 10b4bc <_Thread_queue_Flush> <== NOT EXECUTED 00109e98 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 109e98: 55 push %ebp <== NOT EXECUTED 109e99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e9b: 53 push %ebx <== NOT EXECUTED 109e9c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109e9f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109ea2: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 109ea5: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 109ea7: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 109eaa: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 109ead: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 109eb0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 109eb3: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 109eb6: 6a 03 push $0x3 <== NOT EXECUTED 109eb8: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 109ebd: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ebf: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 109ec3: 0f 94 c0 sete %al <== NOT EXECUTED 109ec6: 50 push %eax <== NOT EXECUTED 109ec7: 51 push %ecx <== NOT EXECUTED 109ec8: e8 17 16 00 00 call 10b4e4 <_Thread_queue_Initialize> <== NOT EXECUTED 109ecd: 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 ); } 109ed0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ed3: c9 leave <== NOT EXECUTED 109ed4: c3 ret <== NOT EXECUTED 001112c0 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 1112c0: 55 push %ebp <== NOT EXECUTED 1112c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1112c3: 57 push %edi <== NOT EXECUTED 1112c4: 56 push %esi <== NOT EXECUTED 1112c5: 53 push %ebx <== NOT EXECUTED 1112c6: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1112c9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1112cc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1112cf: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 1112d2: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 1112d5: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 1112d8: 8b 15 b0 34 12 00 mov 0x1234b0,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 1112de: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 1112e5: 9c pushf <== NOT EXECUTED 1112e6: fa cli <== NOT EXECUTED 1112e7: 5b pop %ebx <== NOT EXECUTED if ( the_semaphore->count != 0 ) { 1112e8: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 1112eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1112ed: 74 08 je 1112f7 <_CORE_semaphore_Seize+0x37> <== NOT EXECUTED the_semaphore->count -= 1; 1112ef: 48 dec %eax <== NOT EXECUTED 1112f0: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 1112f3: 53 push %ebx <== NOT EXECUTED 1112f4: 9d popf <== NOT EXECUTED 1112f5: eb 37 jmp 11132e <_CORE_semaphore_Seize+0x6e> <== NOT EXECUTED /* * If the semaphore was not available and the caller was not willing * to block, then return immediately with a status indicating that * the semaphore was not available and the caller never blocked. */ if ( !wait ) { 1112f7: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 1112fb: 75 0b jne 111308 <_CORE_semaphore_Seize+0x48> <== NOT EXECUTED _ISR_Enable( level ); 1112fd: 53 push %ebx <== NOT EXECUTED 1112fe: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 1112ff: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) <== NOT EXECUTED 111306: eb 26 jmp 11132e <_CORE_semaphore_Seize+0x6e> <== 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 111308: c7 41 30 01 00 00 00 movl $0x1,0x30(%ecx) <== NOT EXECUTED /* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 11130f: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 111312: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED _ISR_Enable( level ); 111315: 53 push %ebx <== NOT EXECUTED 111316: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 111317: c7 45 10 10 e4 10 00 movl $0x10e410,0x10(%ebp) <== NOT EXECUTED 11131e: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 111321: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 111324: 5a pop %edx <== NOT EXECUTED 111325: 5b pop %ebx <== NOT EXECUTED 111326: 5e pop %esi <== NOT EXECUTED 111327: 5f pop %edi <== NOT EXECUTED 111328: c9 leave <== NOT EXECUTED */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 111329: e9 de cd ff ff jmp 10e10c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED } 11132e: 58 pop %eax <== NOT EXECUTED 11132f: 5b pop %ebx <== NOT EXECUTED 111330: 5e pop %esi <== NOT EXECUTED 111331: 5f pop %edi <== NOT EXECUTED 111332: c9 leave <== NOT EXECUTED 111333: c3 ret <== NOT EXECUTED 00109ed8 <_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 ) { 109ed8: 55 push %ebp <== NOT EXECUTED 109ed9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109edb: 53 push %ebx <== NOT EXECUTED 109edc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109edf: 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)) ) { 109ee2: 53 push %ebx <== NOT EXECUTED 109ee3: e8 b0 12 00 00 call 10b198 <_Thread_queue_Dequeue> <== NOT EXECUTED 109ee8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109eeb: 31 d2 xor %edx,%edx <== NOT EXECUTED 109eed: 85 c0 test %eax,%eax <== NOT EXECUTED 109eef: 75 18 jne 109f09 <_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 ); 109ef1: 9c pushf <== NOT EXECUTED 109ef2: fa cli <== NOT EXECUTED 109ef3: 59 pop %ecx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 109ef4: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109ef7: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 109efc: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 109eff: 73 06 jae 109f07 <_CORE_semaphore_Surrender+0x2f> <== NOT EXECUTED the_semaphore->count += 1; 109f01: 40 inc %eax <== NOT EXECUTED 109f02: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 109f05: 31 d2 xor %edx,%edx <== NOT EXECUTED else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 109f07: 51 push %ecx <== NOT EXECUTED 109f08: 9d popf <== NOT EXECUTED } return status; } 109f09: 89 d0 mov %edx,%eax <== NOT EXECUTED 109f0b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109f0e: c9 leave <== NOT EXECUTED 109f0f: c3 ret <== NOT EXECUTED 0010a700 <_CORE_spinlock_Initialize>: void _CORE_spinlock_Initialize( CORE_spinlock_Control *the_spinlock, CORE_spinlock_Attributes *the_spinlock_attributes ) { 10a700: 55 push %ebp <== NOT EXECUTED 10a701: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a703: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_spinlock->Attributes = *the_spinlock_attributes; 10a706: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a709: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10a70b: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_spinlock->lock = 0; 10a70d: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED the_spinlock->users = 0; 10a714: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) <== NOT EXECUTED the_spinlock->holder = 0; 10a71b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED } 10a722: c9 leave <== NOT EXECUTED 10a723: c3 ret <== NOT EXECUTED 0010a724 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 10a724: 55 push %ebp <== NOT EXECUTED 10a725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a727: 53 push %ebx <== NOT EXECUTED 10a728: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10a72b: 9c pushf <== NOT EXECUTED 10a72c: fa cli <== NOT EXECUTED 10a72d: 5b pop %ebx <== NOT EXECUTED /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10a72e: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10a731: 85 c0 test %eax,%eax <== NOT EXECUTED 10a733: 75 06 jne 10a73b <_CORE_spinlock_Release+0x17> <== NOT EXECUTED _ISR_Enable( level ); 10a735: 53 push %ebx <== NOT EXECUTED 10a736: 9d popf <== NOT EXECUTED 10a737: b0 06 mov $0x6,%al <== NOT EXECUTED 10a739: eb 2f jmp 10a76a <_CORE_spinlock_Release+0x46> <== NOT EXECUTED } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 10a73b: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10a73e: a1 b8 e6 11 00 mov 0x11e6b8,%eax <== NOT EXECUTED 10a743: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10a746: 74 09 je 10a751 <_CORE_spinlock_Release+0x2d> <== NOT EXECUTED _ISR_Enable( level ); 10a748: 53 push %ebx <== NOT EXECUTED 10a749: 9d popf <== NOT EXECUTED 10a74a: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10a74f: eb 19 jmp 10a76a <_CORE_spinlock_Release+0x46> <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 10a751: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10a754: 48 dec %eax <== NOT EXECUTED 10a755: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 10a758: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED the_spinlock->holder = 0; 10a75f: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10a766: 53 push %ebx <== NOT EXECUTED 10a767: 9d popf <== NOT EXECUTED 10a768: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_SPINLOCK_SUCCESSFUL; } 10a76a: 5b pop %ebx <== NOT EXECUTED 10a76b: c9 leave <== NOT EXECUTED 10a76c: c3 ret <== NOT EXECUTED 0010a770 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) { 10a770: 55 push %ebp <== NOT EXECUTED 10a771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a773: 57 push %edi <== NOT EXECUTED 10a774: 56 push %esi <== NOT EXECUTED 10a775: 53 push %ebx <== NOT EXECUTED 10a776: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a779: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a77c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10a77f: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 10a782: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 10a785: a1 48 e7 11 00 mov 0x11e748,%eax <== NOT EXECUTED 10a78a: 8d 34 07 lea (%edi,%eax,1),%esi <== NOT EXECUTED _ISR_Disable( level ); 10a78d: 9c pushf <== NOT EXECUTED 10a78e: fa cli <== NOT EXECUTED 10a78f: 59 pop %ecx <== NOT EXECUTED if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10a790: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10a793: 48 dec %eax <== NOT EXECUTED 10a794: 75 16 jne 10a7ac <_CORE_spinlock_Wait+0x3c> <== NOT EXECUTED 10a796: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10a799: a1 b8 e6 11 00 mov 0x11e6b8,%eax <== NOT EXECUTED 10a79e: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10a7a1: 75 09 jne 10a7ac <_CORE_spinlock_Wait+0x3c> <== NOT EXECUTED (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 10a7a3: 51 push %ecx <== NOT EXECUTED 10a7a4: 9d popf <== NOT EXECUTED 10a7a5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a7aa: eb 70 jmp 10a81c <_CORE_spinlock_Wait+0xac> <== NOT EXECUTED return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 10a7ac: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a7af: 40 inc %eax <== NOT EXECUTED 10a7b0: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10a7b3: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10a7b6: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7b8: 75 18 jne 10a7d2 <_CORE_spinlock_Wait+0x62> <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_LOCKED; 10a7ba: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED the_spinlock->holder = _Thread_Executing->Object.id; 10a7c1: a1 b8 e6 11 00 mov 0x11e6b8,%eax <== NOT EXECUTED 10a7c6: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a7c9: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a7cc: 51 push %ecx <== NOT EXECUTED 10a7cd: 9d popf <== NOT EXECUTED 10a7ce: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a7d0: eb 4a jmp 10a81c <_CORE_spinlock_Wait+0xac> <== NOT EXECUTED } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 10a7d2: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10a7d6: 75 10 jne 10a7e8 <_CORE_spinlock_Wait+0x78> <== NOT EXECUTED the_spinlock->users -= 1; 10a7d8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a7db: 48 dec %eax <== NOT EXECUTED 10a7dc: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a7df: 51 push %ecx <== NOT EXECUTED 10a7e0: 9d popf <== NOT EXECUTED 10a7e1: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a7e6: eb 34 jmp 10a81c <_CORE_spinlock_Wait+0xac> <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 10a7e8: 85 ff test %edi,%edi <== NOT EXECUTED 10a7ea: 74 19 je 10a805 <_CORE_spinlock_Wait+0x95> <== NOT EXECUTED 10a7ec: a1 48 e7 11 00 mov 0x11e748,%eax <== NOT EXECUTED 10a7f1: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10a7f3: 77 10 ja 10a805 <_CORE_spinlock_Wait+0x95> <== NOT EXECUTED the_spinlock->users -= 1; 10a7f5: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a7f8: 48 dec %eax <== NOT EXECUTED 10a7f9: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a7fc: 51 push %ecx <== NOT EXECUTED 10a7fd: 9d popf <== NOT EXECUTED 10a7fe: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10a803: eb 17 jmp 10a81c <_CORE_spinlock_Wait+0xac> <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 10a805: 51 push %ecx <== NOT EXECUTED 10a806: 9d popf <== NOT EXECUTED /* An ISR could occur here */ _Thread_Enable_dispatch(); 10a807: e8 68 0f 00 00 call 10b774 <_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 10a80c: a1 f8 e5 11 00 mov 0x11e5f8,%eax <== NOT EXECUTED 10a811: 40 inc %eax <== NOT EXECUTED 10a812: a3 f8 e5 11 00 mov %eax,0x11e5f8 <== NOT EXECUTED /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10a817: 9c pushf <== NOT EXECUTED 10a818: fa cli <== NOT EXECUTED 10a819: 59 pop %ecx <== NOT EXECUTED 10a81a: eb 97 jmp 10a7b3 <_CORE_spinlock_Wait+0x43> <== NOT EXECUTED } } 10a81c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a81f: 5b pop %ebx <== NOT EXECUTED 10a820: 5e pop %esi <== NOT EXECUTED 10a821: 5f pop %edi <== NOT EXECUTED 10a822: c9 leave <== NOT EXECUTED 10a823: c3 ret <== NOT EXECUTED 00109ac0 <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 109ac0: 55 push %ebp <== NOT EXECUTED 109ac1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ac3: 53 push %ebx <== NOT EXECUTED 109ac4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109ac7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 109aca: 9c pushf <== NOT EXECUTED 109acb: fa cli <== NOT EXECUTED 109acc: 5b pop %ebx <== NOT EXECUTED 109acd: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109ad0: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109ad2: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 109ad5: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 109ad8: 89 10 mov %edx,(%eax) <== NOT EXECUTED 109ada: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 109add: 53 push %ebx <== NOT EXECUTED 109ade: 9d popf <== NOT EXECUTED } 109adf: 5b pop %ebx <== NOT EXECUTED 109ae0: c9 leave <== NOT EXECUTED 109ae1: c3 ret <== NOT EXECUTED 0010dcd4 <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10dcd4: 55 push %ebp <== NOT EXECUTED 10dcd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcd7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10dcda: 9c pushf <== NOT EXECUTED 10dcdb: fa cli <== NOT EXECUTED 10dcdc: 59 pop %ecx <== NOT EXECUTED 10dcdd: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10dcdf: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10dce2: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10dce5: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10dce7: 51 push %ecx <== NOT EXECUTED 10dce8: 9d popf <== NOT EXECUTED } 10dce9: c9 leave <== NOT EXECUTED 10dcea: c3 ret <== NOT EXECUTED 00109ae4 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 109ae4: 55 push %ebp <== NOT EXECUTED 109ae5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ae7: 53 push %ebx <== NOT EXECUTED 109ae8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 109aeb: 9c pushf <== NOT EXECUTED 109aec: fa cli <== NOT EXECUTED 109aed: 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( 109aee: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 109af0: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109af3: 39 c2 cmp %eax,%edx <== NOT EXECUTED 109af5: 75 04 jne 109afb <_Chain_Get+0x17> <== NOT EXECUTED 109af7: 31 d2 xor %edx,%edx <== NOT EXECUTED 109af9: eb 07 jmp 109b02 <_Chain_Get+0x1e> <== NOT EXECUTED 109afb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 109afd: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 109aff: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 109b02: 53 push %ebx <== NOT EXECUTED 109b03: 9d popf <== NOT EXECUTED return return_node; } 109b04: 89 d0 mov %edx,%eax <== NOT EXECUTED 109b06: 5b pop %ebx <== NOT EXECUTED 109b07: c9 leave <== NOT EXECUTED 109b08: c3 ret <== NOT EXECUTED 0010dcec <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10dcec: 55 push %ebp <== NOT EXECUTED 10dced: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcef: 56 push %esi <== NOT EXECUTED 10dcf0: 53 push %ebx <== NOT EXECUTED 10dcf1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10dcf4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10dcf7: 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 10dcfa: 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; 10dcfc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED next = starting_address; 10dd03: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dd06: eb 0a jmp 10dd12 <_Chain_Initialize+0x26> <== NOT EXECUTED while ( count-- ) { current->next = next; 10dd08: 89 02 mov %eax,(%edx) <== NOT EXECUTED next->previous = current; 10dd0a: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10dd0d: 49 dec %ecx <== NOT EXECUTED 10dd0e: 89 c2 mov %eax,%edx <== NOT EXECUTED 10dd10: 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-- ) { 10dd12: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10dd14: 75 f2 jne 10dd08 <_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 ); 10dd16: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10dd19: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_chain->last = current; 10dd1b: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED } 10dd1e: 5b pop %ebx <== NOT EXECUTED 10dd1f: 5e pop %esi <== NOT EXECUTED 10dd20: c9 leave <== NOT EXECUTED 10dd21: c3 ret <== NOT EXECUTED 00121d60 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 121d60: 55 push %ebp <== NOT EXECUTED 121d61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121d63: 53 push %ebx <== NOT EXECUTED 121d64: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 121d67: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 121d6a: 9c pushf <== NOT EXECUTED 121d6b: fa cli <== NOT EXECUTED 121d6c: 5b pop %ebx <== NOT EXECUTED 121d6d: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 121d70: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 121d72: 89 02 mov %eax,(%edx) <== NOT EXECUTED 121d74: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 121d76: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 121d79: 53 push %ebx <== NOT EXECUTED 121d7a: 9d popf <== NOT EXECUTED } 121d7b: 5b pop %ebx <== NOT EXECUTED 121d7c: c9 leave <== NOT EXECUTED 121d7d: c3 ret <== NOT EXECUTED 0010dc81 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10dc81: 55 push %ebp <== NOT EXECUTED 10dc82: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dc87: 85 05 3c d7 11 00 test %eax,0x11d73c <== NOT EXECUTED 10dc8d: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10dc90: c9 leave <== NOT EXECUTED 10dc91: c3 ret <== NOT EXECUTED 0010dc54 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10dc54: 55 push %ebp <== NOT EXECUTED 10dc55: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10dc57: c7 05 3c d7 11 00 00 movl $0x0,0x11d73c <== NOT EXECUTED 10dc5e: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10dc61: c9 leave <== NOT EXECUTED 10dc62: c3 ret <== NOT EXECUTED 0010d8f0 <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10d8f0: 55 push %ebp <== NOT EXECUTED 10d8f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d8f6: 6a 04 push $0x4 <== NOT EXECUTED 10d8f8: 6a 00 push $0x0 <== NOT EXECUTED 10d8fa: 6a 1c push $0x1c <== NOT EXECUTED 10d8fc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d8ff: 6a 07 push $0x7 <== NOT EXECUTED 10d901: 6a 02 push $0x2 <== NOT EXECUTED 10d903: 68 38 e0 11 00 push $0x11e038 <== NOT EXECUTED 10d908: e8 eb cd ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d90d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d910: c9 leave <== NOT EXECUTED 10d911: c3 ret <== NOT EXECUTED 0010d914 <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10d914: 55 push %ebp <== NOT EXECUTED 10d915: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10d917: c7 05 6c df 11 00 00 movl $0x0,0x11df6c <== NOT EXECUTED 10d91e: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10d921: c9 leave <== NOT EXECUTED 10d922: 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 38 d7 11 00 mov 0x11d738,%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 6c df 11 00 01 movl $0x1,0x11df6c <== 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 58 d7 11 00 push $0x11d758 <== NOT EXECUTED 108c67: e8 90 2f 00 00 call 10bbfc <_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 d4 29 00 00 call 10b650 <_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 6c df 11 00 mov 0x11df6c,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 108c84: c7 05 6c df 11 00 00 movl $0x0,0x11df6c <== 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 c5 1c 00 00 jmp 10a974 <_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 14 d7 11 00 mov 0x11d714,%eax <== NOT EXECUTED 108d39: 85 c0 test %eax,%eax <== NOT EXECUTED 108d3b: 74 49 je 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d3d: 3b 1d 38 d7 11 00 cmp 0x11d738,%ebx <== NOT EXECUTED 108d43: 75 41 jne 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d45: a1 6c df 11 00 mov 0x11df6c,%eax <== NOT EXECUTED 108d4a: 48 dec %eax <== NOT EXECUTED 108d4b: 74 0a je 108d57 <_Event_Surrender+0x53> <== NOT EXECUTED 108d4d: a1 6c df 11 00 mov 0x11df6c,%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 6c df 11 00 03 movl $0x3,0x11df6c <== 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 43 2f 00 00 call 10bd14 <_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 02 1d 00 00 call 10aae0 <_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 7e 20 00 00 call 10ae80 <_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 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 108e1b: 48 dec %eax <== NOT EXECUTED 108e1c: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 38 d7 11 00 cmp 0x11d738,%eax <== NOT EXECUTED 108e32: 75 14 jne 108e48 <_Event_Timeout+0x58> <== NOT EXECUTED Thread_blocking_operation_States sync = _Event_Sync_state; 108e34: a1 6c df 11 00 mov 0x11df6c,%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 6c df 11 00 02 movl $0x2,0x11df6c <== 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 82 1c 00 00 call 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 108e5e: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 108e63: 48 dec %eax <== NOT EXECUTED 108e64: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 00109744 <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 109744: 55 push %ebp <== NOT EXECUTED 109745: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109747: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10974a: 6a 04 push $0x4 <== NOT EXECUTED 10974c: 6a 00 push $0x0 <== NOT EXECUTED 10974e: 6a 44 push $0x44 <== NOT EXECUTED 109750: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109753: 6a 09 push $0x9 <== NOT EXECUTED 109755: 6a 02 push $0x2 <== NOT EXECUTED 109757: 68 b0 df 11 00 push $0x11dfb0 <== NOT EXECUTED 10975c: e8 97 0f 00 00 call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 109761: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 109764: c9 leave <== NOT EXECUTED 109765: c3 ret <== NOT EXECUTED 0010df20 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10df20: 55 push %ebp <== NOT EXECUTED 10df21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df23: 57 push %edi <== NOT EXECUTED 10df24: 56 push %esi <== NOT EXECUTED 10df25: 53 push %ebx <== NOT EXECUTED 10df26: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10df29: 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 = 10df2c: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10df2f: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10df32: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df35: e8 d5 c1 ff ff call 10a10f <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10df3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df3d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10df3f: 85 c0 test %eax,%eax <== NOT EXECUTED 10df41: 74 3c je 10df7f <_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( 10df43: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED 10df46: 31 ff xor %edi,%edi <== NOT EXECUTED 10df48: eb 27 jmp 10df71 <_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) { 10df4a: 39 43 04 cmp %eax,0x4(%ebx) <== NOT EXECUTED 10df4d: 72 1e jb 10df6d <_Heap_Allocate+0x4d> <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10df4f: 52 push %edx <== NOT EXECUTED 10df50: 50 push %eax <== NOT EXECUTED 10df51: 53 push %ebx <== NOT EXECUTED 10df52: 56 push %esi <== NOT EXECUTED 10df53: e8 f4 c1 ff ff call 10a14c <_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 10df58: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10df5b: ff 46 48 incl 0x48(%esi) <== NOT EXECUTED stats->searches += search_count + 1; 10df5e: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10df61: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax <== NOT EXECUTED 10df65: 89 46 4c mov %eax,0x4c(%esi) <== NOT EXECUTED 10df68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df6b: eb 0a jmp 10df77 <_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) 10df6d: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10df70: 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; 10df71: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10df73: 75 d5 jne 10df4a <_Heap_Allocate+0x2a> <== NOT EXECUTED 10df75: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10df77: 39 7e 44 cmp %edi,0x44(%esi) <== NOT EXECUTED 10df7a: 73 03 jae 10df7f <_Heap_Allocate+0x5f> <== NOT EXECUTED stats->max_search = search_count; 10df7c: 89 7e 44 mov %edi,0x44(%esi) <== NOT EXECUTED return ptr; } 10df7f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10df81: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10df84: 5b pop %ebx <== NOT EXECUTED 10df85: 5e pop %esi <== NOT EXECUTED 10df86: 5f pop %edi <== NOT EXECUTED 10df87: c9 leave <== NOT EXECUTED 10df88: c3 ret <== NOT EXECUTED 0010b7cc <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10b7cc: 55 push %ebp <== NOT EXECUTED 10b7cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7cf: 57 push %edi <== NOT EXECUTED 10b7d0: 56 push %esi <== NOT EXECUTED 10b7d1: 53 push %ebx <== NOT EXECUTED 10b7d2: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED 10b7d5: 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; 10b7d8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7db: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10b7de: 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; 10b7e1: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10b7e4: 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); 10b7e7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7ea: ff 72 14 pushl 0x14(%edx) <== NOT EXECUTED 10b7ed: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10b7f0: 50 push %eax <== NOT EXECUTED 10b7f1: e8 2d 04 00 00 call 10bc23 <_Heap_Calc_block_size> <== NOT EXECUTED 10b7f6: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10b7f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7fc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b7fe: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10b802: 0f 84 30 01 00 00 je 10b938 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED return NULL; if(alignment == 0) 10b808: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10b80c: 75 07 jne 10b815 <_Heap_Allocate_aligned+0x49> <== NOT EXECUTED 10b80e: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10b815: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b818: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED 10b81b: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED 10b822: e9 f8 00 00 00 jmp 10b91f <_Heap_Allocate_aligned+0x153> <== NOT EXECUTED 10b827: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b82a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10b82d: 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. */ 10b830: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10b833: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b835: 0f 82 de 00 00 00 jb 10b919 <_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)); 10b83b: 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; 10b83e: 01 d8 add %ebx,%eax <== NOT EXECUTED 10b840: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10b843: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b845: 2b 75 e0 sub -0x20(%ebp),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10b848: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b84a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b84c: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b84f: 89 f7 mov %esi,%edi <== NOT EXECUTED 10b851: 29 d7 sub %edx,%edi <== NOT EXECUTED 10b853: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b855: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b857: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10b85a: 89 fe mov %edi,%esi <== NOT EXECUTED 10b85c: 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) { 10b85e: 39 ce cmp %ecx,%esi <== NOT EXECUTED 10b860: 0f 82 b3 00 00 00 jb 10b919 <_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) { 10b866: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b869: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b86c: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b86f: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b871: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b873: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b875: 73 2f jae 10b8a6 <_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) { 10b877: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b879: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b87b: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b87d: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b880: 72 24 jb 10b8a6 <_Heap_Allocate_aligned+0xda> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10b882: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b884: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b886: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b889: 89 d6 mov %edx,%esi <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10b88b: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b88d: 85 f6 test %esi,%esi <== NOT EXECUTED 10b88f: 74 08 je 10b899 <_Heap_Allocate_aligned+0xcd> <== NOT EXECUTED 10b891: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b894: 8d 14 01 lea (%ecx,%eax,1),%edx <== NOT EXECUTED 10b897: 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) { 10b899: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b89b: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b89d: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b8a0: 73 77 jae 10b919 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED 10b8a2: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b8a4: 89 d7 mov %edx,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10b8a6: 85 ff test %edi,%edi <== NOT EXECUTED 10b8a8: 74 6f je 10b919 <_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; 10b8aa: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10b8ad: 83 c2 08 add $0x8,%edx <== NOT EXECUTED 10b8b0: 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; 10b8b2: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 10b8b5: 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) { 10b8b7: 3b 4d f0 cmp -0x10(%ebp),%ecx <== NOT EXECUTED 10b8ba: 72 14 jb 10b8d0 <_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; 10b8bc: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b8be: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b8c1: 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 ); 10b8c4: 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 10b8c7: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10b8c9: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10b8cb: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10b8ce: eb 15 jmp 10b8e5 <_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 ) { 10b8d0: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10b8d3: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10b8d6: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10b8d9: 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; 10b8dc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8df: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b8e2: 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; 10b8e5: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10b8ea: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b8ed: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10b8f0: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b8f2: 89 41 30 mov %eax,0x30(%ecx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b8f5: 39 41 34 cmp %eax,0x34(%ecx) <== NOT EXECUTED 10b8f8: 76 03 jbe 10b8fd <_Heap_Allocate_aligned+0x131> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b8fa: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10b8fd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b900: 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; 10b903: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b905: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10b908: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 10b90b: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax <== NOT EXECUTED 10b90f: 89 42 4c mov %eax,0x4c(%edx) <== NOT EXECUTED stats->allocs += 1; 10b912: 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; 10b915: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b917: eb 11 jmp 10b92a <_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) 10b919: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10b91c: 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; 10b91f: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10b922: 0f 85 ff fe ff ff jne 10b827 <_Heap_Allocate_aligned+0x5b> <== NOT EXECUTED 10b928: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10b92a: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b92d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b930: 39 51 44 cmp %edx,0x44(%ecx) <== NOT EXECUTED 10b933: 73 03 jae 10b938 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED stats->max_search = search_count; 10b935: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED return user_ptr; } 10b938: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b93b: 5b pop %ebx <== NOT EXECUTED 10b93c: 5e pop %esi <== NOT EXECUTED 10b93d: 5f pop %edi <== NOT EXECUTED 10b93e: c9 leave <== NOT EXECUTED 10b93f: c3 ret <== NOT EXECUTED 0010a14c <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10a14c: 55 push %ebp <== NOT EXECUTED 10a14d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a14f: 57 push %edi <== NOT EXECUTED 10a150: 56 push %esi <== NOT EXECUTED 10a151: 53 push %ebx <== NOT EXECUTED 10a152: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a155: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10a158: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a15b: 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; 10a15e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a160: 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) { 10a162: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a165: 3b 5a 14 cmp 0x14(%edx),%ebx <== NOT EXECUTED 10a168: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10a16b: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 10a16e: 72 24 jb 10a194 <_Heap_Block_allocate+0x48> <== NOT EXECUTED 10a170: 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 10a173: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED ); 10a176: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10a179: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10a17c: 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; 10a17f: 89 fa mov %edi,%edx <== NOT EXECUTED 10a181: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a184: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10a187: 89 da mov %ebx,%edx <== NOT EXECUTED 10a189: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a18c: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10a18f: 89 1c 18 mov %ebx,(%eax,%ebx,1) <== NOT EXECUTED 10a192: eb 13 jmp 10a1a7 <_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 10a194: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10a197: 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; 10a19a: 83 4c 06 04 01 orl $0x1,0x4(%esi,%eax,1) <== NOT EXECUTED stats->free_blocks -= 1; 10a19f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a1a2: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10a1a5: 89 c7 mov %eax,%edi <== NOT EXECUTED } /* Update statistics */ stats->free_size -= alloc_size; 10a1a7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a1aa: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10a1ad: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a1af: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10a1b2: 39 42 34 cmp %eax,0x34(%edx) <== NOT EXECUTED 10a1b5: 76 03 jbe 10a1ba <_Heap_Block_allocate+0x6e> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10a1b7: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10a1ba: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a1bd: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10a1c0: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a1c2: 5b pop %ebx <== NOT EXECUTED 10a1c3: 5e pop %esi <== NOT EXECUTED 10a1c4: 5f pop %edi <== NOT EXECUTED 10a1c5: c9 leave <== NOT EXECUTED 10a1c6: c3 ret <== NOT EXECUTED 0010a10f <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10a10f: 55 push %ebp <== NOT EXECUTED 10a110: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a112: 57 push %edi <== NOT EXECUTED 10a113: 56 push %esi <== NOT EXECUTED 10a114: 53 push %ebx <== NOT EXECUTED 10a115: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a118: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a11b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a11e: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10a121: 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 10a124: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a126: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a128: f7 f1 div %ecx <== NOT EXECUTED */ 10a12a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a12c: 74 05 je 10a133 <_Heap_Calc_block_size+0x24> <== NOT EXECUTED 10a12e: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 10a131: 29 d7 sub %edx,%edi <== NOT EXECUTED 10a133: 89 fa mov %edi,%edx <== NOT EXECUTED 10a135: 39 df cmp %ebx,%edi <== NOT EXECUTED 10a137: 73 02 jae 10a13b <_Heap_Calc_block_size+0x2c> <== NOT EXECUTED 10a139: 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; 10a13b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a13d: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a13f: 0f 97 c0 seta %al <== NOT EXECUTED 10a142: f7 d8 neg %eax <== NOT EXECUTED 10a144: 21 d0 and %edx,%eax <== NOT EXECUTED } 10a146: 5a pop %edx <== NOT EXECUTED 10a147: 5b pop %ebx <== NOT EXECUTED 10a148: 5e pop %esi <== NOT EXECUTED 10a149: 5f pop %edi <== NOT EXECUTED 10a14a: c9 leave <== NOT EXECUTED 10a14b: c3 ret <== NOT EXECUTED 0010fef8 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 10fef8: 55 push %ebp <== NOT EXECUTED 10fef9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fefb: 57 push %edi <== NOT EXECUTED 10fefc: 56 push %esi <== NOT EXECUTED 10fefd: 53 push %ebx <== NOT EXECUTED 10fefe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ff01: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ff04: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ff07: 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 */ 10ff0a: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 10ff0d: 72 0a jb 10ff19 <_Heap_Extend+0x21> <== NOT EXECUTED 10ff0f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10ff14: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10ff17: 72 5f jb 10ff78 <_Heap_Extend+0x80> <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 10ff19: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10ff1e: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10ff21: 75 55 jne 10ff78 <_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; 10ff23: 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 ); 10ff26: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 10ff29: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 10ff2c: 29 d8 sub %ebx,%eax <== NOT EXECUTED 10ff2e: 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) || \ 10ff31: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ff33: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff35: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 10ff38: 29 d7 sub %edx,%edi <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 10ff3a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ff3d: 89 30 mov %esi,(%eax) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 10ff3f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ff41: 3b 79 14 cmp 0x14(%ecx),%edi <== NOT EXECUTED 10ff44: 72 32 jb 10ff78 <_Heap_Extend+0x80> <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 10ff46: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ff49: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10ff4c: 09 f8 or %edi,%eax <== NOT EXECUTED 10ff4e: 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 10ff51: 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; 10ff54: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 10ff5b: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 10ff5e: 01 71 2c add %esi,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10ff61: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 10ff64: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 10ff67: 50 push %eax <== NOT EXECUTED 10ff68: 50 push %eax <== NOT EXECUTED 10ff69: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ff6c: 50 push %eax <== NOT EXECUTED 10ff6d: 51 push %ecx <== NOT EXECUTED 10ff6e: e8 39 ba ff ff call 10b9ac <_Heap_Free> <== NOT EXECUTED 10ff73: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ff75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; } 10ff78: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ff7b: 5b pop %ebx <== NOT EXECUTED 10ff7c: 5e pop %esi <== NOT EXECUTED 10ff7d: 5f pop %edi <== NOT EXECUTED 10ff7e: c9 leave <== NOT EXECUTED 10ff7f: c3 ret <== NOT EXECUTED 0010df8c <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10df8c: 55 push %ebp <== NOT EXECUTED 10df8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df8f: 57 push %edi <== NOT EXECUTED 10df90: 56 push %esi <== NOT EXECUTED 10df91: 53 push %ebx <== NOT EXECUTED 10df92: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10df95: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10df98: 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( 10df9b: 8b 47 24 mov 0x24(%edi),%eax <== NOT EXECUTED 10df9e: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10dfa1: 8b 57 20 mov 0x20(%edi),%edx <== NOT EXECUTED 10dfa4: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 10dfa7: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10dfa9: 0f 93 c2 setae %dl <== NOT EXECUTED 10dfac: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10dfae: 0f 96 c0 setbe %al <== NOT EXECUTED 10dfb1: 84 d0 test %dl,%al <== NOT EXECUTED 10dfb3: 0f 84 2f 01 00 00 je 10e0e8 <_Heap_Free+0x15c> <== NOT EXECUTED 10dfb9: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 10dfbc: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dfbe: 31 d2 xor %edx,%edx <== NOT EXECUTED 10dfc0: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10dfc3: 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 ) ) { 10dfc5: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10dfc8: 0f 93 c2 setae %dl <== NOT EXECUTED 10dfcb: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10dfce: 0f 96 c0 setbe %al <== NOT EXECUTED 10dfd1: 84 d0 test %dl,%al <== NOT EXECUTED 10dfd3: 0f 84 0f 01 00 00 je 10e0e8 <_Heap_Free+0x15c> <== NOT EXECUTED 10dfd9: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 10dfdc: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dfde: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10dfe1: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10dfe4: 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 ) ) { 10dfe7: 3b 75 e4 cmp -0x1c(%ebp),%esi <== NOT EXECUTED 10dfea: 0f 93 c2 setae %dl <== NOT EXECUTED 10dfed: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10dff0: 0f 96 c0 setbe %al <== NOT EXECUTED 10dff3: 84 d0 test %dl,%al <== NOT EXECUTED 10dff5: 0f 84 ed 00 00 00 je 10e0e8 <_Heap_Free+0x15c> <== NOT EXECUTED 10dffb: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10dffe: a8 01 test $0x1,%al <== NOT EXECUTED 10e000: 0f 84 e2 00 00 00 je 10e0e8 <_Heap_Free+0x15c> <== NOT EXECUTED 10e006: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10e009: 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 && 10e00c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e00e: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10e011: 73 0c jae 10e01f <_Heap_Free+0x93> <== NOT EXECUTED 10e013: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10e016: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax <== NOT EXECUTED 10e01a: f7 d0 not %eax <== NOT EXECUTED 10e01c: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10e01f: 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 ) ) { 10e022: 80 e1 01 and $0x1,%cl <== NOT EXECUTED 10e025: 75 56 jne 10e07d <_Heap_Free+0xf1> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10e027: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10e029: 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 ) ) { 10e02b: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10e02e: 0f 93 c2 setae %dl <== NOT EXECUTED 10e031: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10e034: 0f 96 c0 setbe %al <== NOT EXECUTED 10e037: 84 d0 test %dl,%al <== NOT EXECUTED 10e039: 0f 84 a9 00 00 00 je 10e0e8 <_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) ) { 10e03f: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10e043: 0f 84 9f 00 00 00 je 10e0e8 <_Heap_Free+0x15c> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10e049: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10e04d: 74 19 je 10e068 <_Heap_Free+0xdc> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10e04f: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10e052: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10e055: 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 10e057: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10e05a: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10e05d: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10e060: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10e063: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED 10e066: eb 33 jmp 10e09b <_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; 10e068: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10e06b: 01 ca add %ecx,%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10e06d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e06f: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10e072: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10e075: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = size; 10e079: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10e07b: eb 5b jmp 10e0d8 <_Heap_Free+0x14c> <== NOT EXECUTED } } else if ( next_is_free ) { /* coalesce next */ 10e07d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10e081: 74 25 je 10e0a8 <_Heap_Free+0x11c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10e083: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10e086: 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 */ 10e089: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10e08c: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10e08f: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10e092: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10e095: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10e098: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10e09b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e09d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10e0a0: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10e0a3: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10e0a6: eb 30 jmp 10e0d8 <_Heap_Free+0x14c> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10e0a8: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10e0ab: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10e0ae: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e0b1: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10e0b4: 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; 10e0b7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10e0ba: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10e0bd: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10e0c0: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = the_size; 10e0c4: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10e0c7: 89 06 mov %eax,(%esi) <== NOT EXECUTED stats->free_blocks += 1; 10e0c9: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10e0cc: 40 inc %eax <== NOT EXECUTED 10e0cd: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10e0d0: 39 47 3c cmp %eax,0x3c(%edi) <== NOT EXECUTED 10e0d3: 73 03 jae 10e0d8 <_Heap_Free+0x14c> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10e0d5: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED } stats->used_blocks -= 1; 10e0d8: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10e0db: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10e0de: 01 57 30 add %edx,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10e0e1: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10e0e4: b0 01 mov $0x1,%al <== NOT EXECUTED 10e0e6: eb 02 jmp 10e0ea <_Heap_Free+0x15e> <== NOT EXECUTED return( TRUE ); 10e0e8: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10e0ea: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10e0ed: 5b pop %ebx <== NOT EXECUTED 10e0ee: 5e pop %esi <== NOT EXECUTED 10e0ef: 5f pop %edi <== NOT EXECUTED 10e0f0: c9 leave <== NOT EXECUTED 10e0f1: c3 ret <== NOT EXECUTED 001221e4 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1221e4: 55 push %ebp <== NOT EXECUTED 1221e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1221e7: 53 push %ebx <== NOT EXECUTED 1221e8: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1221eb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 1221ee: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED info->largest = 0; 1221f4: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED info->total = 0; 1221fb: 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( 122202: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 122205: eb 16 jmp 12221d <_Heap_Get_free_information+0x39> <== NOT EXECUTED 122207: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 12220a: 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++; 12220d: ff 02 incl (%edx) <== NOT EXECUTED info->total += the_size; 12220f: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( info->largest < the_size ) 122212: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 122215: 73 03 jae 12221a <_Heap_Get_free_information+0x36> <== NOT EXECUTED info->largest = the_size; 122217: 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) 12221a: 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; 12221d: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12221f: 75 e6 jne 122207 <_Heap_Get_free_information+0x23> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 122221: 5b pop %ebx <== NOT EXECUTED 122222: c9 leave <== NOT EXECUTED 122223: c3 ret <== NOT EXECUTED 0012a070 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 12a070: 55 push %ebp <== NOT EXECUTED 12a071: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12a073: 53 push %ebx <== NOT EXECUTED 12a074: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12a077: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 12a07a: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 12a07d: 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; 12a080: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED the_info->Free.total = 0; 12a086: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED the_info->Free.largest = 0; 12a08d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED the_info->Used.number = 0; 12a094: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED the_info->Used.total = 0; 12a09b: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED the_info->Used.largest = 0; 12a0a2: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 12a0a9: eb 36 jmp 12a0e1 <_Heap_Get_information+0x71> <== NOT EXECUTED 12a0ab: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 12a0ae: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 12a0b1: 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) ) { 12a0b3: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 12a0b7: 74 10 je 12a0c9 <_Heap_Get_information+0x59> <== NOT EXECUTED the_info->Used.number++; 12a0b9: ff 42 0c incl 0xc(%edx) <== NOT EXECUTED the_info->Used.total += the_size; 12a0bc: 01 42 14 add %eax,0x14(%edx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 12a0bf: 39 42 10 cmp %eax,0x10(%edx) <== NOT EXECUTED 12a0c2: 73 1d jae 12a0e1 <_Heap_Get_information+0x71> <== NOT EXECUTED the_info->Used.largest = the_size; 12a0c4: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED 12a0c7: eb 18 jmp 12a0e1 <_Heap_Get_information+0x71> <== NOT EXECUTED } else { the_info->Free.number++; 12a0c9: ff 02 incl (%edx) <== NOT EXECUTED the_info->Free.total += the_size; 12a0cb: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 12a0ce: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 12a0d1: 73 03 jae 12a0d6 <_Heap_Get_information+0x66> <== NOT EXECUTED the_info->Free.largest = the_size; 12a0d3: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 12a0d6: 3b 01 cmp (%ecx),%eax <== NOT EXECUTED 12a0d8: 74 07 je 12a0e1 <_Heap_Get_information+0x71> <== NOT EXECUTED 12a0da: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 12a0df: eb 0a jmp 12a0eb <_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 ) { 12a0e1: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12a0e3: 75 c6 jne 12a0ab <_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; 12a0e5: 83 42 14 08 addl $0x8,0x14(%edx) <== NOT EXECUTED 12a0e9: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 12a0eb: 5b pop %ebx <== NOT EXECUTED 12a0ec: c9 leave <== NOT EXECUTED 12a0ed: c3 ret <== NOT EXECUTED 0010a000 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10a000: 55 push %ebp <== NOT EXECUTED 10a001: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a003: 57 push %edi <== NOT EXECUTED 10a004: 56 push %esi <== NOT EXECUTED 10a005: 53 push %ebx <== NOT EXECUTED 10a006: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a009: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a00c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10a00f: 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) 10a012: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a014: 75 04 jne 10a01a <_Heap_Initialize+0x1a> <== NOT EXECUTED 10a016: b1 04 mov $0x4,%cl <== NOT EXECUTED 10a018: eb 0c jmp 10a026 <_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 */ 10a01a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a01c: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10a01f: 74 05 je 10a026 <_Heap_Initialize+0x26> <== NOT EXECUTED 10a021: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 10a024: 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; 10a026: 8d 5f 08 lea 0x8(%edi),%ebx <== NOT EXECUTED 10a029: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a02b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a02d: f7 f1 div %ecx <== NOT EXECUTED 10a02f: 85 d2 test %edx,%edx <== NOT EXECUTED 10a031: 74 05 je 10a038 <_Heap_Initialize+0x38> <== NOT EXECUTED 10a033: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 10a036: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10a038: 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 10a03b: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10a040: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a042: f7 f1 div %ecx <== NOT EXECUTED */ 10a044: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10a049: 85 d2 test %edx,%edx <== NOT EXECUTED 10a04b: 74 05 je 10a052 <_Heap_Initialize+0x52> <== NOT EXECUTED 10a04d: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10a050: 29 d0 sub %edx,%eax <== NOT EXECUTED 10a052: 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); 10a055: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a057: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a059: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 10a05c: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 10a05f: 0f 82 a0 00 00 00 jb 10a105 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 10a065: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10a068: 29 c2 sub %eax,%edx <== NOT EXECUTED 10a06a: 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 10a06d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a06f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a071: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10a073: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10a076: 29 d0 sub %edx,%eax <== NOT EXECUTED 10a078: 89 c2 mov %eax,%edx <== NOT EXECUTED 10a07a: 0f 84 85 00 00 00 je 10a105 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10a080: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED the_heap->begin = starting_address; 10a083: 89 7e 18 mov %edi,0x18(%esi) <== NOT EXECUTED the_heap->end = starting_address + size; 10a086: 03 7d 10 add 0x10(%ebp),%edi <== NOT EXECUTED 10a089: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10a08c: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 10a08e: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10a091: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 10a094: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 10a097: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 10a09a: 89 5e 08 mov %ebx,0x8(%esi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 10a09d: 89 5e 0c mov %ebx,0xc(%esi) <== NOT EXECUTED the_heap->start = the_block; 10a0a0: 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 10a0a3: 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 */ 10a0a6: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10a0a9: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = page_size; 10a0ab: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10a0ae: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a0b1: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED stats->free_size = the_size; 10a0b4: 89 56 30 mov %edx,0x30(%esi) <== NOT EXECUTED stats->min_free_size = the_size; 10a0b7: 89 56 34 mov %edx,0x34(%esi) <== NOT EXECUTED stats->free_blocks = 1; 10a0ba: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) <== NOT EXECUTED stats->max_free_blocks = 1; 10a0c1: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi) <== NOT EXECUTED stats->used_blocks = 0; 10a0c8: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) <== NOT EXECUTED stats->max_search = 0; 10a0cf: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) <== NOT EXECUTED stats->allocs = 0; 10a0d6: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED stats->searches = 0; 10a0dd: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) <== NOT EXECUTED stats->frees = 0; 10a0e4: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED stats->resizes = 0; 10a0eb: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED stats->instance = instance++; 10a0f2: a1 2c d4 11 00 mov 0x11d42c,%eax <== NOT EXECUTED 10a0f7: 89 46 28 mov %eax,0x28(%esi) <== NOT EXECUTED 10a0fa: 40 inc %eax <== NOT EXECUTED 10a0fb: a3 2c d4 11 00 mov %eax,0x11d42c <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10a100: 8d 42 fc lea -0x4(%edx),%eax <== NOT EXECUTED 10a103: eb 02 jmp 10a107 <_Heap_Initialize+0x107> <== NOT EXECUTED 10a105: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10a107: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a10a: 5b pop %ebx <== NOT EXECUTED 10a10b: 5e pop %esi <== NOT EXECUTED 10a10c: 5f pop %edi <== NOT EXECUTED 10a10d: c9 leave <== NOT EXECUTED 10a10e: c3 ret <== NOT EXECUTED 001159e4 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 1159e4: 55 push %ebp <== NOT EXECUTED 1159e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1159e7: 57 push %edi <== NOT EXECUTED 1159e8: 56 push %esi <== NOT EXECUTED 1159e9: 53 push %ebx <== NOT EXECUTED 1159ea: 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; 1159ed: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1159f0: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 1159f3: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 1159f6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1159f9: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED *old_mem_size = 0; 1159fc: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 1159ff: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED *avail_mem_size = 0; 115a05: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115a08: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 115a0e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 115a11: 83 ea 08 sub $0x8,%edx <== NOT EXECUTED 115a14: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 115a17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 115a1a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 115a1d: 31 d2 xor %edx,%edx <== NOT EXECUTED 115a1f: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 115a22: 29 55 f0 sub %edx,-0x10(%ebp) <== NOT EXECUTED 115a25: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115a27: 8b 49 24 mov 0x24(%ecx),%ecx <== NOT EXECUTED 115a2a: 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)) 115a2d: 39 5d f0 cmp %ebx,-0x10(%ebp) <== NOT EXECUTED 115a30: 0f 93 c2 setae %dl <== NOT EXECUTED 115a33: 39 4d f0 cmp %ecx,-0x10(%ebp) <== NOT EXECUTED 115a36: 0f 96 c0 setbe %al <== NOT EXECUTED 115a39: 84 d0 test %dl,%al <== NOT EXECUTED 115a3b: 0f 84 7e 01 00 00 je 115bbf <_Heap_Resize_block+0x1db> <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 115a41: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115a44: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED 115a47: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 115a4a: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 115a4d: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 115a50: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 115a53: 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) || 115a55: 39 df cmp %ebx,%edi <== NOT EXECUTED 115a57: 0f 93 c2 setae %dl <== NOT EXECUTED 115a5a: 39 cf cmp %ecx,%edi <== NOT EXECUTED 115a5c: 0f 96 c0 setbe %al <== NOT EXECUTED 115a5f: 84 d0 test %dl,%al <== NOT EXECUTED 115a61: 0f 84 58 01 00 00 je 115bbf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115a67: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 115a6a: a8 01 test $0x1,%al <== NOT EXECUTED 115a6c: 0f 84 4d 01 00 00 je 115bbf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115a72: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115a75: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 115a78: 01 f8 add %edi,%eax <== NOT EXECUTED 115a7a: 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) || 115a7d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 115a82: 39 cf cmp %ecx,%edi <== NOT EXECUTED 115a84: 74 09 je 115a8f <_Heap_Resize_block+0xab> <== NOT EXECUTED 115a86: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 115a89: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 115a8c: 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; 115a8f: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 115a92: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 115a95: 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) || 115a98: 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) 115a9a: 89 f8 mov %edi,%eax <== NOT EXECUTED 115a9c: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 115a9f: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 115aa2: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 115aa5: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 115aa7: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 115aaa: 76 50 jbe 115afc <_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 */ 115aac: 84 c9 test %cl,%cl <== NOT EXECUTED 115aae: 0f 85 12 01 00 00 jne 115bc6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 115ab4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 115ab7: 29 c1 sub %eax,%ecx <== NOT EXECUTED 115ab9: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115abb: 31 d2 xor %edx,%edx <== NOT EXECUTED 115abd: f7 f6 div %esi <== NOT EXECUTED 115abf: 85 d2 test %edx,%edx <== NOT EXECUTED 115ac1: 74 04 je 115ac7 <_Heap_Resize_block+0xe3> <== NOT EXECUTED 115ac3: 01 f1 add %esi,%ecx <== NOT EXECUTED 115ac5: 29 d1 sub %edx,%ecx <== NOT EXECUTED 115ac7: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115ac9: 3b 4d ec cmp -0x14(%ebp),%ecx <== NOT EXECUTED 115acc: 73 03 jae 115ad1 <_Heap_Resize_block+0xed> <== NOT EXECUTED 115ace: 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) 115ad1: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 115ad4: 0f 87 ec 00 00 00 ja 115bc6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 115ada: 53 push %ebx <== NOT EXECUTED 115adb: 50 push %eax <== NOT EXECUTED 115adc: 57 push %edi <== NOT EXECUTED 115add: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115ae0: e8 67 46 ff ff call 10a14c <_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; 115ae5: 03 45 e4 add -0x1c(%ebp),%eax <== NOT EXECUTED 115ae8: 0b 45 e8 or -0x18(%ebp),%eax <== NOT EXECUTED 115aeb: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115aee: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED --stats->used_blocks; 115af1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 115af4: ff 49 40 decl 0x40(%ecx) <== NOT EXECUTED 115af7: e9 b6 00 00 00 jmp 115bb2 <_Heap_Resize_block+0x1ce> <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 115afc: 89 c3 mov %eax,%ebx <== NOT EXECUTED 115afe: 2b 5d 10 sub 0x10(%ebp),%ebx <== NOT EXECUTED 115b01: 89 d8 mov %ebx,%eax <== NOT EXECUTED 115b03: 31 d2 xor %edx,%edx <== NOT EXECUTED 115b05: f7 f6 div %esi <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 115b07: 89 de mov %ebx,%esi <== NOT EXECUTED 115b09: 29 d6 sub %edx,%esi <== NOT EXECUTED 115b0b: 0f 84 a4 00 00 00 je 115bb5 <_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; 115b11: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED 115b14: 29 f3 sub %esi,%ebx <== NOT EXECUTED if (new_block_size < min_block_size) { 115b16: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 115b19: 73 16 jae 115b31 <_Heap_Resize_block+0x14d> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 115b1b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 115b1e: 29 d8 sub %ebx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 115b20: 29 c6 sub %eax,%esi <== NOT EXECUTED 115b22: 75 0b jne 115b2f <_Heap_Resize_block+0x14b> <== NOT EXECUTED ++stats->resizes; 115b24: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115b27: ff 42 54 incl 0x54(%edx) <== NOT EXECUTED 115b2a: e9 8c 00 00 00 jmp 115bbb <_Heap_Resize_block+0x1d7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 115b2f: 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) { 115b31: 84 c9 test %cl,%cl <== NOT EXECUTED 115b33: 75 43 jne 115b78 <_Heap_Resize_block+0x194> <== NOT EXECUTED 115b35: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115b38: 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; 115b3a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 115b3d: 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; 115b40: 0b 5d e8 or -0x18(%ebp),%ebx <== NOT EXECUTED 115b43: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 115b46: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 115b49: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115b4b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 115b4e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 115b51: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 115b54: 89 08 mov %ecx,(%eax) <== NOT EXECUTED { return (state == SYSTEM_STATE_FAILED); } /**@}*/ 115b56: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED #endif 115b59: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED /* end of include file */ 115b5c: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 115b5f: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 115b62: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 115b65: 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; 115b68: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115b6b: 01 72 30 add %esi,0x30(%edx) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 115b6e: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 115b71: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115b74: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 115b76: eb 3d jmp 115bb5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 115b78: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED 115b7b: 72 38 jb 115bb5 <_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; 115b7d: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED 115b80: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 115b83: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115b86: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED 115b89: 89 d0 mov %edx,%eax <== NOT EXECUTED 115b8b: 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; 115b8d: 89 f2 mov %esi,%edx <== NOT EXECUTED 115b8f: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 115b92: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 115b95: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115b98: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 115b9b: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 115b9e: 51 push %ecx <== NOT EXECUTED 115b9f: 51 push %ecx <== NOT EXECUTED 115ba0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 115ba3: 50 push %eax <== NOT EXECUTED 115ba4: 52 push %edx <== NOT EXECUTED 115ba5: e8 e2 83 ff ff call 10df8c <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 115baa: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED 115bad: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 115bb0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 115bb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } ++stats->resizes; 115bb5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 115bb8: ff 40 54 incl 0x54(%eax) <== NOT EXECUTED 115bbb: 31 c0 xor %eax,%eax <== NOT EXECUTED 115bbd: eb 0c jmp 115bcb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 115bbf: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 115bc4: eb 05 jmp 115bcb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED 115bc6: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } 115bcb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115bce: 5b pop %ebx <== NOT EXECUTED 115bcf: 5e pop %esi <== NOT EXECUTED 115bd0: 5f pop %edi <== NOT EXECUTED 115bd1: c9 leave <== NOT EXECUTED 115bd2: c3 ret <== NOT EXECUTED 00115bd4 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 115bd4: 55 push %ebp <== NOT EXECUTED 115bd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115bd7: 57 push %edi <== NOT EXECUTED 115bd8: 56 push %esi <== NOT EXECUTED 115bd9: 53 push %ebx <== NOT EXECUTED 115bda: 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( 115bdd: 8b 7e 24 mov 0x24(%esi),%edi <== NOT EXECUTED 115be0: 8b 5e 20 mov 0x20(%esi),%ebx <== NOT EXECUTED 115be3: 39 5d 0c cmp %ebx,0xc(%ebp) <== NOT EXECUTED 115be6: 0f 93 c2 setae %dl <== NOT EXECUTED 115be9: 39 7d 0c cmp %edi,0xc(%ebp) <== NOT EXECUTED 115bec: 0f 96 c0 setbe %al <== NOT EXECUTED 115bef: 84 d0 test %dl,%al <== NOT EXECUTED 115bf1: 74 49 je 115c3c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115bf3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 115bf6: 83 e9 08 sub $0x8,%ecx <== NOT EXECUTED 115bf9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 115bfc: 31 d2 xor %edx,%edx <== NOT EXECUTED 115bfe: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 115c01: 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 ) ) 115c03: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 115c05: 0f 93 c2 setae %dl <== NOT EXECUTED 115c08: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 115c0a: 0f 96 c0 setbe %al <== NOT EXECUTED 115c0d: 84 d0 test %dl,%al <== NOT EXECUTED 115c0f: 74 2b je 115c3c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115c11: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 115c14: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115c17: 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 ( 115c19: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 115c1b: 0f 93 c2 setae %dl <== NOT EXECUTED 115c1e: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 115c20: 0f 96 c0 setbe %al <== NOT EXECUTED 115c23: 84 d0 test %dl,%al <== NOT EXECUTED 115c25: 74 15 je 115c3c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115c27: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 115c2b: 74 0f je 115c3c <_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 ) 115c2d: 2b 4d 0c sub 0xc(%ebp),%ecx <== NOT EXECUTED 115c30: 8d 51 04 lea 0x4(%ecx),%edx <== NOT EXECUTED 115c33: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115c36: 89 10 mov %edx,(%eax) <== NOT EXECUTED 115c38: b0 01 mov $0x1,%al <== NOT EXECUTED 115c3a: eb 02 jmp 115c3e <_Heap_Size_of_user_area+0x6a> <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 115c3c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 115c3e: 5b pop %ebx <== NOT EXECUTED 115c3f: 5e pop %esi <== NOT EXECUTED 115c40: 5f pop %edi <== NOT EXECUTED 115c41: c9 leave <== NOT EXECUTED 115c42: c3 ret <== NOT EXECUTED 001100b0 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 1100b0: 55 push %ebp <== NOT EXECUTED 1100b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1100b3: 57 push %edi <== NOT EXECUTED 1100b4: 56 push %esi <== NOT EXECUTED 1100b5: 53 push %ebx <== NOT EXECUTED 1100b6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1100b9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 1100bc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1100bf: 8b 70 20 mov 0x20(%eax),%esi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 1100c2: 8b 50 24 mov 0x24(%eax),%edx <== NOT EXECUTED 1100c5: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 1100c8: 85 db test %ebx,%ebx <== NOT EXECUTED 1100ca: 79 03 jns 1100cf <_Heap_Walk+0x1f> <== NOT EXECUTED source = the_heap->stats.instance; 1100cc: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 1100cf: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 1100d1: f6 46 04 01 testb $0x1,0x4(%esi) <== NOT EXECUTED 1100d5: 75 15 jne 1100ec <_Heap_Walk+0x3c> <== NOT EXECUTED printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 1100d7: 50 push %eax <== NOT EXECUTED 1100d8: 50 push %eax <== NOT EXECUTED 1100d9: 53 push %ebx <== NOT EXECUTED 1100da: 68 04 ba 11 00 push $0x11ba04 <== NOT EXECUTED 1100df: e8 c6 83 ff ff call 1084aa <== NOT EXECUTED 1100e4: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1100e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (the_block->prev_size != the_heap->page_size) { 1100ec: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1100ee: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1100f1: 3b 47 10 cmp 0x10(%edi),%eax <== NOT EXECUTED 1100f4: 0f 84 38 01 00 00 je 110232 <_Heap_Walk+0x182> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 1100fa: 50 push %eax <== NOT EXECUTED 1100fb: 50 push %eax <== NOT EXECUTED 1100fc: 53 push %ebx <== NOT EXECUTED 1100fd: 68 3a ba 11 00 push $0x11ba3a <== NOT EXECUTED 110102: e8 a3 83 ff ff call 1084aa <== NOT EXECUTED 110107: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 11010c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11010f: e9 1e 01 00 00 jmp 110232 <_Heap_Walk+0x182> <== NOT EXECUTED 110114: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 110117: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11011a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 11011d: 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 110120: 01 f0 add %esi,%eax <== NOT EXECUTED 110122: 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)) { 110125: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 110128: 3b 42 20 cmp 0x20(%edx),%eax <== NOT EXECUTED 11012b: 0f 93 c2 setae %dl <== NOT EXECUTED 11012e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 110131: 3b 47 24 cmp 0x24(%edi),%eax <== NOT EXECUTED 110134: 0f 96 c0 setbe %al <== NOT EXECUTED 110137: 84 d0 test %dl,%al <== NOT EXECUTED 110139: 75 0f jne 11014a <_Heap_Walk+0x9a> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 11013b: 50 push %eax <== NOT EXECUTED 11013c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 11013f: 53 push %ebx <== NOT EXECUTED 110140: 68 6c ba 11 00 push $0x11ba6c <== NOT EXECUTED 110145: e9 d7 00 00 00 jmp 110221 <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 11014a: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11014d: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 110151: 0f 85 85 00 00 00 jne 1101dc <_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) { 110157: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 11015a: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 11015c: 74 15 je 110173 <_Heap_Walk+0xc3> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 11015e: 50 push %eax <== NOT EXECUTED 11015f: 50 push %eax <== NOT EXECUTED 110160: 53 push %ebx <== NOT EXECUTED 110161: 68 8f ba 11 00 push $0x11ba8f <== NOT EXECUTED 110166: e8 3f 83 ff ff call 1084aa <== NOT EXECUTED 11016b: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 110170: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 110173: f6 45 f0 01 testb $0x1,-0x10(%ebp) <== NOT EXECUTED 110177: 75 29 jne 1101a2 <_Heap_Walk+0xf2> <== NOT EXECUTED if (do_dump || error) printk("\n"); 110179: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11017b: 74 10 je 11018d <_Heap_Walk+0xdd> <== NOT EXECUTED 11017d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110180: 68 c1 b5 11 00 push $0x11b5c1 <== NOT EXECUTED 110185: e8 20 83 ff ff call 1084aa <== NOT EXECUTED 11018a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 11018d: 57 push %edi <== NOT EXECUTED 11018e: 57 push %edi <== NOT EXECUTED 11018f: 53 push %ebx <== NOT EXECUTED 110190: 68 ba ba 11 00 push $0x11baba <== NOT EXECUTED 110195: e8 10 83 ff ff call 1084aa <== NOT EXECUTED 11019a: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 11019f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 1101a2: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1101a5: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 1101a8: eb 03 jmp 1101ad <_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; 1101aa: 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) 1101ad: 39 f0 cmp %esi,%eax <== NOT EXECUTED 1101af: 74 2b je 1101dc <_Heap_Walk+0x12c> <== NOT EXECUTED 1101b1: 3b 45 08 cmp 0x8(%ebp),%eax <== NOT EXECUTED 1101b4: 75 f4 jne 1101aa <_Heap_Walk+0xfa> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 1101b6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1101b8: 74 10 je 1101ca <_Heap_Walk+0x11a> <== NOT EXECUTED 1101ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1101bd: 68 c1 b5 11 00 push $0x11b5c1 <== NOT EXECUTED 1101c2: e8 e3 82 ff ff call 1084aa <== NOT EXECUTED 1101c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 1101ca: 51 push %ecx <== NOT EXECUTED 1101cb: 51 push %ecx <== NOT EXECUTED 1101cc: 53 push %ebx <== NOT EXECUTED 1101cd: 68 e4 ba 11 00 push $0x11bae4 <== NOT EXECUTED 1101d2: e8 d3 82 ff ff call 1084aa <== NOT EXECUTED 1101d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1101da: eb 04 jmp 1101e0 <_Heap_Walk+0x130> <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 1101dc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1101de: 74 15 je 1101f5 <_Heap_Walk+0x145> <== NOT EXECUTED 1101e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1101e3: 68 c1 b5 11 00 push $0x11b5c1 <== NOT EXECUTED 1101e8: e8 bd 82 ff ff call 1084aa <== NOT EXECUTED 1101ed: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1101f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 1101f5: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 1101f8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1101fb: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 1101fe: 73 0a jae 11020a <_Heap_Walk+0x15a> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 110200: 52 push %edx <== NOT EXECUTED 110201: 52 push %edx <== NOT EXECUTED 110202: 53 push %ebx <== NOT EXECUTED 110203: 68 0d bb 11 00 push $0x11bb0d <== NOT EXECUTED 110208: eb 17 jmp 110221 <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 11020a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11020d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 110210: 31 d2 xor %edx,%edx <== NOT EXECUTED 110212: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 110215: 85 d2 test %edx,%edx <== NOT EXECUTED 110217: 74 12 je 11022b <_Heap_Walk+0x17b> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); 110219: 50 push %eax <== NOT EXECUTED 11021a: 50 push %eax <== NOT EXECUTED 11021b: 53 push %ebx <== NOT EXECUTED 11021c: 68 30 bb 11 00 push $0x11bb30 <== NOT EXECUTED 110221: e8 84 82 ff ff call 1084aa <== NOT EXECUTED 110226: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110229: eb 12 jmp 11023d <_Heap_Walk+0x18d> <== NOT EXECUTED error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 11022b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11022d: 75 0e jne 11023d <_Heap_Walk+0x18d> <== NOT EXECUTED break; 11022f: 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 ) { 110232: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 110235: 0f 85 d9 fe ff ff jne 110114 <_Heap_Walk+0x64> <== NOT EXECUTED 11023b: eb 17 jmp 110254 <_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", 11023d: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 110240: 56 push %esi <== NOT EXECUTED 110241: 53 push %ebx <== NOT EXECUTED 110242: 68 54 bb 11 00 push $0x11bb54 <== NOT EXECUTED 110247: e8 5e 82 ff ff call 1084aa <== NOT EXECUTED 11024c: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 110251: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110254: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 110257: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 11025a: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11025d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 110260: 39 d0 cmp %edx,%eax <== NOT EXECUTED 110262: 74 15 je 110279 <_Heap_Walk+0x1c9> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 110264: 52 push %edx <== NOT EXECUTED 110265: 50 push %eax <== NOT EXECUTED 110266: 53 push %ebx <== NOT EXECUTED 110267: 68 8f bb 11 00 push $0x11bb8f <== NOT EXECUTED 11026c: e8 39 82 ff ff call 1084aa <== NOT EXECUTED 110271: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 110276: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110279: 88 c8 mov %cl,%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 11027b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11027e: 5b pop %ebx <== NOT EXECUTED 11027f: 5e pop %esi <== NOT EXECUTED 110280: 5f pop %edi <== NOT EXECUTED 110281: c9 leave <== NOT EXECUTED 110282: c3 ret <== NOT EXECUTED 0010977c <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10977c: 55 push %ebp <== NOT EXECUTED 10977d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10977f: 53 push %ebx <== NOT EXECUTED 109780: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109783: 31 db xor %ebx,%ebx <== NOT EXECUTED 109785: eb 0f jmp 109796 <_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 ); 109787: 50 push %eax <== NOT EXECUTED 109788: 6a 00 push $0x0 <== NOT EXECUTED 10978a: 6a 00 push $0x0 <== NOT EXECUTED 10978c: 53 push %ebx <== NOT EXECUTED 10978d: e8 02 45 00 00 call 10dc94 <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 109792: 43 inc %ebx <== NOT EXECUTED 109793: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109796: 3b 1d f0 df 11 00 cmp 0x11dff0,%ebx <== NOT EXECUTED 10979c: 72 e9 jb 109787 <_IO_Initialize_all_drivers+0xb> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 10979e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1097a1: c9 leave <== NOT EXECUTED 1097a2: c3 ret <== NOT EXECUTED 001097a3 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 1097a3: 55 push %ebp <== NOT EXECUTED 1097a4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097a6: 57 push %edi <== NOT EXECUTED 1097a7: 56 push %esi <== NOT EXECUTED 1097a8: 53 push %ebx <== NOT EXECUTED 1097a9: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1097ac: 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 ) 1097af: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 1097b2: 76 2f jbe 1097e3 <_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 *) 1097b4: 6b de 18 imul $0x18,%esi,%ebx <== NOT EXECUTED 1097b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097ba: 53 push %ebx <== NOT EXECUTED 1097bb: e8 52 26 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 1097c0: 89 c7 mov %eax,%edi <== NOT EXECUTED 1097c2: a3 f4 df 11 00 mov %eax,0x11dff4 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 1097c7: 89 35 f0 df 11 00 mov %esi,0x11dff0 <== NOT EXECUTED memset( 1097cd: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097cf: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1097d1: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1097d3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1097d6: 8b 15 f4 df 11 00 mov 0x11dff4,%edx <== NOT EXECUTED 1097dc: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1097e1: eb 25 jmp 109808 <_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; 1097e3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1097e6: a3 f4 df 11 00 mov %eax,0x11dff4 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 1097eb: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1097ee: 89 0d f0 df 11 00 mov %ecx,0x11dff0 <== NOT EXECUTED 1097f4: eb 17 jmp 10980d <_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]; 1097f6: 89 d7 mov %edx,%edi <== NOT EXECUTED 1097f8: 89 de mov %ebx,%esi <== NOT EXECUTED 1097fa: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 1097ff: 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++ ) 109801: 40 inc %eax <== NOT EXECUTED 109802: 83 c3 18 add $0x18,%ebx <== NOT EXECUTED 109805: 83 c2 18 add $0x18,%edx <== NOT EXECUTED 109808: 3b 45 0c cmp 0xc(%ebp),%eax <== NOT EXECUTED 10980b: 72 e9 jb 1097f6 <_IO_Manager_initialization+0x53> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10980d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109810: 5b pop %ebx <== NOT EXECUTED 109811: 5e pop %esi <== NOT EXECUTED 109812: 5f pop %edi <== NOT EXECUTED 109813: c9 leave <== NOT EXECUTED 109814: c3 ret <== NOT EXECUTED 0010a208 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10a208: 55 push %ebp <== NOT EXECUTED 10a209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a20b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10a20e: c6 05 cc d7 11 00 00 movb $0x0,0x11d7cc <== NOT EXECUTED _ISR_Nest_level = 0; 10a215: c7 05 14 d7 11 00 00 movl $0x0,0x11d714 <== NOT EXECUTED 10a21c: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10a21f: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10a224: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10a227: 3b 05 60 92 11 00 cmp 0x119260,%eax <== NOT EXECUTED 10a22d: 73 0c jae 10a23b <_ISR_Handler_initialization+0x33> <== NOT EXECUTED _Internal_error_Occurred( 10a22f: 50 push %eax <== NOT EXECUTED 10a230: 6a 05 push $0x5 <== NOT EXECUTED 10a232: 6a 01 push $0x1 <== NOT EXECUTED 10a234: 6a 00 push $0x0 <== NOT EXECUTED 10a236: e8 8d ff ff ff call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error( 10a23b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a23e: 50 push %eax <== NOT EXECUTED 10a23f: e8 ce 1b 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a244: a3 88 d6 11 00 mov %eax,0x11d688 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10a249: 8b 15 10 d7 11 00 mov 0x11d710,%edx <== NOT EXECUTED 10a24f: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10a252: a3 48 d6 11 00 mov %eax,0x11d648 <== NOT EXECUTED 10a257: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10a25a: c9 leave <== NOT EXECUTED 10a25b: c3 ret <== NOT EXECUTED 0010a1c8 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10a1c8: 55 push %ebp <== NOT EXECUTED 10a1c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1cb: 53 push %ebx <== NOT EXECUTED 10a1cc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a1cf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a1d2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a1d5: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10a1d8: 89 15 20 d7 11 00 mov %edx,0x11d720 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10a1de: a2 24 d7 11 00 mov %al,0x11d724 <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10a1e3: 89 1d 28 d7 11 00 mov %ebx,0x11d728 <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10a1e9: 53 push %ebx <== NOT EXECUTED 10a1ea: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a1ed: 50 push %eax <== NOT EXECUTED 10a1ee: 52 push %edx <== NOT EXECUTED 10a1ef: e8 eb 18 00 00 call 10badf <_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( 10a1f4: c7 05 18 d8 11 00 05 movl $0x5,0x11d818 <== NOT EXECUTED 10a1fb: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10a1fe: fa cli <== NOT EXECUTED 10a1ff: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a201: f4 hlt <== NOT EXECUTED 10a202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a205: eb fe jmp 10a205 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010d924 <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10d924: 55 push %ebp <== NOT EXECUTED 10d925: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10d927: c9 leave <== NOT EXECUTED 10d928: c3 ret <== NOT EXECUTED 00121438 <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 121438: 55 push %ebp <== NOT EXECUTED 121439: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12143b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 12143e: 68 f0 b6 15 00 push $0x15b6f0 <== NOT EXECUTED 121443: e8 0c d8 fe ff call 10ec54 <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 121448: c9 leave <== NOT EXECUTED 121449: c3 ret <== NOT EXECUTED 0010d92c <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10d92c: 55 push %ebp <== NOT EXECUTED 10d92d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d92f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d932: 6a 04 push $0x4 <== NOT EXECUTED 10d934: 6a 00 push $0x0 <== NOT EXECUTED 10d936: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10d93b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d93e: 6a 04 push $0x4 <== NOT EXECUTED 10d940: 6a 02 push $0x2 <== NOT EXECUTED 10d942: 68 70 df 11 00 push $0x11df70 <== NOT EXECUTED 10d947: e8 ac cd ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d94c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10d94f: c9 leave <== NOT EXECUTED 10d950: 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 2c b5 11 00 mov 0x11b52c(,%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 0010e0f4 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10e0f4: 55 push %ebp <== NOT EXECUTED 10e0f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e0f7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED switch (api) { 10e0fa: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e0ff: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10e102: 74 1b je 10e11f <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED 10e104: 77 05 ja 10e10b <_Objects_API_maximum_class+0x17> <== NOT EXECUTED 10e106: b0 02 mov $0x2,%al <== NOT EXECUTED 10e108: 4a dec %edx <== NOT EXECUTED 10e109: eb 0f jmp 10e11a <_Objects_API_maximum_class+0x26> <== NOT EXECUTED 10e10b: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10e110: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10e113: 74 0a je 10e11f <_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; 10e115: b0 08 mov $0x8,%al <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10e117: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10e11a: 74 03 je 10e11f <_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; 10e11c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10e11f: c9 leave <== NOT EXECUTED 10e120: c3 ret <== NOT EXECUTED 0010a25c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10a25c: 55 push %ebp <== NOT EXECUTED 10a25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a25f: 56 push %esi <== NOT EXECUTED 10a260: 53 push %ebx <== NOT EXECUTED 10a261: 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 ) 10a264: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a266: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10a26a: 74 59 je 10a2c5 <_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 ); 10a26c: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10a26f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a272: 56 push %esi <== NOT EXECUTED 10a273: e8 6c f8 ff ff call 109ae4 <_Chain_Get> <== NOT EXECUTED 10a278: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10a27a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a27d: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a281: 74 42 je 10a2c5 <_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 ) { 10a283: 85 c0 test %eax,%eax <== NOT EXECUTED 10a285: 75 1a jne 10a2a1 <_Objects_Allocate+0x45> <== NOT EXECUTED _Objects_Extend_information( information ); 10a287: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a28a: 53 push %ebx <== NOT EXECUTED 10a28b: e8 64 00 00 00 call 10a2f4 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10a290: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a293: e8 4c f8 ff ff call 109ae4 <_Chain_Get> <== NOT EXECUTED 10a298: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10a29a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a29d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a29f: 74 24 je 10a2c5 <_Objects_Allocate+0x69> <== NOT EXECUTED uint32_t block; block = _Objects_Get_index( the_object->id ) - 10a2a1: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10a2a4: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a2a9: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a2ac: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a2b2: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10a2b4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a2b6: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a2b9: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a2bc: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a2bf: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10a2c1: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10a2c5: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a2c7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a2ca: 5b pop %ebx <== NOT EXECUTED 10a2cb: 5e pop %esi <== NOT EXECUTED 10a2cc: c9 leave <== NOT EXECUTED 10a2cd: c3 ret <== NOT EXECUTED 0010a2d0 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10a2d0: 55 push %ebp <== NOT EXECUTED 10a2d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2d3: 53 push %ebx <== NOT EXECUTED 10a2d4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a2d7: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a2da: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10a2de: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a2e1: 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 ); 10a2e8: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10a2eb: 5b pop %ebx <== NOT EXECUTED 10a2ec: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10a2ed: e9 c2 04 00 00 jmp 10a7b4 <_Objects_Namespace_remove> <== NOT EXECUTED 0010a2f4 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10a2f4: 55 push %ebp <== NOT EXECUTED 10a2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2f7: 57 push %edi <== NOT EXECUTED 10a2f8: 56 push %esi <== NOT EXECUTED 10a2f9: 53 push %ebx <== NOT EXECUTED 10a2fa: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 10a2fd: 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 10a300: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a303: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a308: 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 ) 10a30b: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a30f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a311: 73 13 jae 10a326 <_Objects_Extend_information+0x32> <== NOT EXECUTED 10a313: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a316: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) <== NOT EXECUTED 10a31d: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a324: eb 35 jmp 10a35b <_Objects_Extend_information+0x67> <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; 10a326: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED 10a329: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a32b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a32d: f7 f7 div %edi <== NOT EXECUTED 10a32f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10a331: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED 10a334: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10a337: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a33a: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a341: eb 13 jmp 10a356 <_Objects_Extend_information+0x62> <== NOT EXECUTED for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 10a343: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a346: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a349: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a34d: 74 0c je 10a35b <_Objects_Extend_information+0x67> <== NOT EXECUTED break; else index_base += information->allocation_size; 10a34f: 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++ ) { 10a352: 42 inc %edx <== NOT EXECUTED 10a353: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 10a356: 39 75 c0 cmp %esi,-0x40(%ebp) <== NOT EXECUTED 10a359: 72 e8 jb 10a343 <_Objects_Extend_information+0x4f> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10a35b: 39 4d c4 cmp %ecx,-0x3c(%ebp) <== NOT EXECUTED 10a35e: 0f 82 30 01 00 00 jb 10a494 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED /* * Up the block count and maximum */ block_count++; 10a364: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED 10a367: 46 inc %esi <== NOT EXECUTED maximum = information->maximum + information->allocation_size; 10a368: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a36b: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10a36e: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a372: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 10a375: 8d 14 39 lea (%ecx,%edi,1),%edx <== NOT EXECUTED 10a378: 74 21 je 10a39b <_Objects_Extend_information+0xa7> <== NOT EXECUTED object_blocks = (void**) 10a37a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a37d: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a380: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a383: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a386: 50 push %eax <== NOT EXECUTED 10a387: e8 71 1a 00 00 call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10a38c: 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 ) 10a38f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a392: 85 c0 test %eax,%eax <== NOT EXECUTED 10a394: 75 1d jne 10a3b3 <_Objects_Extend_information+0xbf> <== NOT EXECUTED 10a396: e9 c9 01 00 00 jmp 10a564 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { object_blocks = (void**) 10a39b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a39e: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a3a1: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a3a4: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a3a7: 50 push %eax <== NOT EXECUTED 10a3a8: e8 65 1a 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a3ad: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED 10a3b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10a3b3: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 10a3b6: 8d 04 b0 lea (%eax,%esi,4),%eax <== NOT EXECUTED 10a3b9: 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 10a3bc: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a3bf: 8d 34 f2 lea (%edx,%esi,8),%esi <== NOT EXECUTED 10a3c2: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10a3c5: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10a3c9: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a3cb: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10a3ce: 76 39 jbe 10a409 <_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, 10a3d0: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 10a3d3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a3d6: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a3d9: 8b 7d a0 mov -0x60(%ebp),%edi <== NOT EXECUTED 10a3dc: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a3de: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10a3e0: 8b 73 30 mov 0x30(%ebx),%esi <== NOT EXECUTED 10a3e3: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a3e6: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a3e8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10a3ea: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a3ee: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10a3f1: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10a3f4: 8b 73 1c mov 0x1c(%ebx),%esi <== NOT EXECUTED 10a3f7: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10a3fa: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a3fc: eb 10 jmp 10a40e <_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; 10a3fe: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a401: 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++ ) { 10a408: 42 inc %edx <== NOT EXECUTED 10a409: 3b 55 c8 cmp -0x38(%ebp),%edx <== NOT EXECUTED 10a40c: 72 f0 jb 10a3fe <_Objects_Extend_information+0x10a> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10a40e: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED 10a411: 8b 4d a0 mov -0x60(%ebp),%ecx <== NOT EXECUTED 10a414: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10a41b: 8b 75 cc mov -0x34(%ebp),%esi <== NOT EXECUTED 10a41e: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a425: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10a428: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a42b: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED 10a42e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a431: 8d 14 b8 lea (%eax,%edi,4),%edx <== NOT EXECUTED 10a434: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a436: eb 0a jmp 10a442 <_Objects_Extend_information+0x14e> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10a438: 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++ ) { 10a43e: 40 inc %eax <== NOT EXECUTED 10a43f: 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 ); 10a442: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10a444: 72 f2 jb 10a438 <_Objects_Extend_information+0x144> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10a446: 9c pushf <== NOT EXECUTED 10a447: fa cli <== NOT EXECUTED 10a448: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10a449: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10a44c: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a44f: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10a452: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a455: 89 7b 30 mov %edi,0x30(%ebx) <== NOT EXECUTED information->local_table = local_table; 10a458: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a45b: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED information->maximum = maximum; 10a45e: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10a461: 66 89 53 10 mov %dx,0x10(%ebx) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10a465: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10a467: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a46a: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a470: 0f b7 43 04 movzwl 0x4(%ebx),%eax <== NOT EXECUTED 10a474: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10a477: 09 c2 or %eax,%edx <== NOT EXECUTED 10a479: 0f b7 45 d0 movzwl -0x30(%ebp),%eax <== NOT EXECUTED 10a47d: 09 c2 or %eax,%edx <== NOT EXECUTED 10a47f: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10a482: 51 push %ecx <== NOT EXECUTED 10a483: 9d popf <== NOT EXECUTED if ( old_tables ) 10a484: 85 f6 test %esi,%esi <== NOT EXECUTED 10a486: 74 0c je 10a494 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED _Workspace_Free( old_tables ); 10a488: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a48b: 56 push %esi <== NOT EXECUTED 10a48c: e8 57 19 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10a491: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10a494: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a498: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10a49b: 74 32 je 10a4cf <_Objects_Extend_information+0x1db> <== NOT EXECUTED information->object_blocks[ block ] = 10a49d: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a4a0: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a4a3: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a4a6: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 10a4a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a4ac: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a4b0: 50 push %eax <== NOT EXECUTED 10a4b1: e8 47 19 00 00 call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10a4b6: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10a4b9: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10a4bb: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a4be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4c1: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a4c4: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a4c8: 75 26 jne 10a4f0 <_Objects_Extend_information+0x1fc> <== NOT EXECUTED 10a4ca: e9 95 00 00 00 jmp 10a564 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 10a4cf: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a4d2: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a4d5: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a4d8: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED 10a4db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a4de: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a4e2: 50 push %eax <== NOT EXECUTED 10a4e3: e8 2a 19 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a4e8: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 10a4eb: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10a4ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10a4f0: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10a4f3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a4f6: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10a4f9: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10a4fc: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10a4ff: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a502: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a505: ff 34 90 pushl (%eax,%edx,4) <== NOT EXECUTED 10a508: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 10a50b: 57 push %edi <== NOT EXECUTED 10a50c: e8 db 37 00 00 call 10dcec <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a511: 8d 4b 20 lea 0x20(%ebx),%ecx <== NOT EXECUTED 10a514: 89 4d b8 mov %ecx,-0x48(%ebp) <== NOT EXECUTED 10a517: 8b 75 c4 mov -0x3c(%ebp),%esi <== NOT EXECUTED 10a51a: eb 24 jmp 10a540 <_Objects_Extend_information+0x24c> <== NOT EXECUTED index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10a51c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10a51e: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10a521: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10a526: 0f b7 53 04 movzwl 0x4(%ebx),%edx <== NOT EXECUTED 10a52a: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10a52d: 09 d0 or %edx,%eax <== NOT EXECUTED 10a52f: 09 f0 or %esi,%eax <== NOT EXECUTED 10a531: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a534: 50 push %eax <== NOT EXECUTED 10a535: 50 push %eax <== NOT EXECUTED 10a536: 51 push %ecx <== NOT EXECUTED 10a537: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 10a53a: e8 81 f5 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED index++; 10a53f: 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 ) { 10a540: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a543: e8 9c f5 ff ff call 109ae4 <_Chain_Get> <== NOT EXECUTED 10a548: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a54a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a54d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a54f: 75 cb jne 10a51c <_Objects_Extend_information+0x228> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10a551: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10a554: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10a557: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10a55a: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10a55d: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10a560: 66 01 43 2c add %ax,0x2c(%ebx) <== NOT EXECUTED } 10a564: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a567: 5b pop %ebx <== NOT EXECUTED 10a568: 5e pop %esi <== NOT EXECUTED 10a569: 5f pop %edi <== NOT EXECUTED 10a56a: c9 leave <== NOT EXECUTED 10a56b: c3 ret <== NOT EXECUTED 0010a56c <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10a56c: 55 push %ebp <== NOT EXECUTED 10a56d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a56f: 57 push %edi <== NOT EXECUTED 10a570: 56 push %esi <== NOT EXECUTED 10a571: 53 push %ebx <== NOT EXECUTED 10a572: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a575: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a578: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10a57b: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10a57e: 56 push %esi <== NOT EXECUTED 10a57f: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10a582: 50 push %eax <== NOT EXECUTED 10a583: e8 38 f5 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10a588: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a58b: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a58f: 74 44 je 10a5d5 <_Objects_Free+0x69> <== NOT EXECUTED uint32_t block; block = 10a591: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a594: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a599: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a59c: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a5a2: 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 ]++; 10a5a4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a5a6: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a5a9: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a5ac: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a5af: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10a5b1: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10a5b4: 42 inc %edx <== NOT EXECUTED 10a5b5: 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 ) ) ) { 10a5b9: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10a5bc: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a5be: d1 e8 shr %eax <== NOT EXECUTED 10a5c0: 01 f8 add %edi,%eax <== NOT EXECUTED 10a5c2: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a5c4: 76 0f jbe 10a5d5 <_Objects_Free+0x69> <== NOT EXECUTED _Objects_Shrink_information( information ); 10a5c6: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10a5c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a5cc: 5b pop %ebx <== NOT EXECUTED 10a5cd: 5e pop %esi <== NOT EXECUTED 10a5ce: 5f pop %edi <== NOT EXECUTED 10a5cf: 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 ); 10a5d0: e9 87 02 00 00 jmp 10a85c <_Objects_Shrink_information> <== NOT EXECUTED } } } 10a5d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a5d8: 5b pop %ebx <== NOT EXECUTED 10a5d9: 5e pop %esi <== NOT EXECUTED 10a5da: 5f pop %edi <== NOT EXECUTED 10a5db: c9 leave <== NOT EXECUTED 10a5dc: c3 ret <== NOT EXECUTED 0010a6a0 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10a6a0: 55 push %ebp <== NOT EXECUTED 10a6a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a6a3: 56 push %esi <== NOT EXECUTED 10a6a4: 53 push %ebx <== NOT EXECUTED 10a6a5: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10a6a8: 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; 10a6ab: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a6b0: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10a6b3: 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 ) { 10a6b6: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10a6ba: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a6bc: 77 2a ja 10a6e8 <_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 10a6be: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10a6c3: 40 inc %eax <== NOT EXECUTED 10a6c4: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10a6c9: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10a6cc: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10a6cf: 85 db test %ebx,%ebx <== NOT EXECUTED 10a6d1: 74 08 je 10a6db <_Objects_Get+0x3b> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a6d3: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 10a6d9: eb 15 jmp 10a6f0 <_Objects_Get+0x50> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10a6db: e8 80 07 00 00 call 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10a6e0: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a6e6: eb 08 jmp 10a6f0 <_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; 10a6e8: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a6ee: 31 db xor %ebx,%ebx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a6f0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a6f2: 5b pop %ebx <== NOT EXECUTED 10a6f3: 5e pop %esi <== NOT EXECUTED 10a6f4: c9 leave <== NOT EXECUTED 10a6f5: c3 ret <== NOT EXECUTED 0010a600 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 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 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a608: 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. 10a60b: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10a60e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a611: 77 2f ja 10a642 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a613: eb 36 jmp 10a64b <_Objects_Get_information+0x4b> <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10a615: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a618: 53 push %ebx <== NOT EXECUTED 10a619: e8 d6 3a 00 00 call 10e0f4 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10a61e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a621: 85 c0 test %eax,%eax <== NOT EXECUTED 10a623: 78 1d js 10a642 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a625: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10a627: 77 19 ja 10a642 <_Objects_Get_information+0x42> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10a629: 8b 04 9d 4c d6 11 00 mov 0x11d64c(,%ebx,4),%eax <== NOT EXECUTED 10a630: 85 c0 test %eax,%eax <== NOT EXECUTED 10a632: 74 0e je 10a642 <_Objects_Get_information+0x42> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10a634: 8b 04 b0 mov (%eax,%esi,4),%eax <== NOT EXECUTED if ( !info ) 10a637: 85 c0 test %eax,%eax <== NOT EXECUTED 10a639: 74 09 je 10a644 <_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 ) 10a63b: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10a640: 75 02 jne 10a644 <_Objects_Get_information+0x44> <== NOT EXECUTED 10a642: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10a644: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a647: 5b pop %ebx <== NOT EXECUTED 10a648: 5e pop %esi <== NOT EXECUTED 10a649: c9 leave <== NOT EXECUTED 10a64a: c3 ret <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10a64b: 85 f6 test %esi,%esi <== NOT EXECUTED 10a64d: 74 f3 je 10a642 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a64f: eb c4 jmp 10a615 <_Objects_Get_information+0x15> <== NOT EXECUTED 0010a5e0 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10a5e0: 55 push %ebp <== NOT EXECUTED 10a5e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5e3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a5e6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10a5e9: 89 c2 mov %eax,%edx <== NOT EXECUTED 10a5eb: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10a5ee: 52 push %edx <== NOT EXECUTED 10a5ef: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a5f2: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a5f5: 50 push %eax <== NOT EXECUTED 10a5f6: e8 05 00 00 00 call 10a600 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10a5fb: c9 leave <== NOT EXECUTED 10a5fc: c3 ret <== NOT EXECUTED 0010a654 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10a654: 55 push %ebp <== NOT EXECUTED 10a655: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a657: 56 push %esi <== NOT EXECUTED 10a658: 53 push %ebx <== NOT EXECUTED 10a659: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a65c: 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; 10a65f: 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 ); 10a663: 9c pushf <== NOT EXECUTED 10a664: fa cli <== NOT EXECUTED 10a665: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10a666: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a66a: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10a66c: 72 21 jb 10a68f <_Objects_Get_isr_disable+0x3b> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10a66e: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10a671: 8b 14 90 mov (%eax,%edx,4),%edx <== NOT EXECUTED 10a674: 85 d2 test %edx,%edx <== NOT EXECUTED 10a676: 74 0d je 10a685 <_Objects_Get_isr_disable+0x31> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a678: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED *level_p = level; 10a67e: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a681: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10a683: eb 14 jmp 10a699 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return the_object; } _ISR_Enable( level ); 10a685: 51 push %ecx <== NOT EXECUTED 10a686: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a687: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a68d: eb 0a jmp 10a699 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return NULL; } _ISR_Enable( level ); 10a68f: 51 push %ecx <== NOT EXECUTED 10a690: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a691: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a697: 31 d2 xor %edx,%edx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a699: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a69b: 5b pop %ebx <== NOT EXECUTED 10a69c: 5e pop %esi <== NOT EXECUTED 10a69d: c9 leave <== NOT EXECUTED 10a69e: c3 ret <== NOT EXECUTED 0011357c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 11357c: 55 push %ebp <== NOT EXECUTED 11357d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11357f: 57 push %edi <== NOT EXECUTED 113580: 56 push %esi <== NOT EXECUTED 113581: 53 push %ebx <== NOT EXECUTED 113582: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 113585: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 113589: 0f 84 b3 00 00 00 je 113642 <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; if ( name == NULL ) 11358f: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 113593: 0f 84 b0 00 00 00 je 113649 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 113599: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 11359c: 85 db test %ebx,%ebx <== NOT EXECUTED 11359e: 75 08 jne 1135a8 <_Objects_Get_name_as_string+0x2c> <== NOT EXECUTED 1135a0: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 1135a5: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 1135a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1135ab: 53 push %ebx <== NOT EXECUTED 1135ac: e8 97 a6 ff ff call 10dc48 <_Objects_Get_information_id> <== NOT EXECUTED 1135b1: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 1135b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1135b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1135b8: 0f 84 84 00 00 00 je 113642 <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 1135be: 50 push %eax <== NOT EXECUTED 1135bf: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1135c2: 50 push %eax <== NOT EXECUTED 1135c3: 53 push %ebx <== NOT EXECUTED 1135c4: 56 push %esi <== NOT EXECUTED 1135c5: e8 3e a7 ff ff call 10dd08 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 1135ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1135cd: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 1135d1: 75 6f jne 113642 <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 1135d3: 80 7e 38 00 cmpb $0x0,0x38(%esi) <== NOT EXECUTED 1135d7: 74 0c je 1135e5 <_Objects_Get_name_as_string+0x69> <== NOT EXECUTED s = the_object->name.name_p; 1135d9: 8b 78 0c mov 0xc(%eax),%edi <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 1135dc: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 1135df: 85 ff test %edi,%edi <== NOT EXECUTED 1135e1: 75 27 jne 11360a <_Objects_Get_name_as_string+0x8e> <== NOT EXECUTED 1135e3: eb 53 jmp 113638 <_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; 1135e5: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 1135e8: 89 d0 mov %edx,%eax <== NOT EXECUTED 1135ea: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 1135ed: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 1135f0: 89 d0 mov %edx,%eax <== NOT EXECUTED 1135f2: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 1135f5: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 1135f8: 89 d0 mov %edx,%eax <== NOT EXECUTED 1135fa: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 1135fd: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 113600: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 113603: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 113607: 8d 7d eb lea -0x15(%ebp),%edi <== NOT EXECUTED 11360a: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 11360d: 31 db xor %ebx,%ebx <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11360f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 113612: 48 dec %eax <== NOT EXECUTED 113613: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 113616: eb 14 jmp 11362c <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 113618: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 11361b: a1 d0 71 12 00 mov 0x1271d0,%eax <== NOT EXECUTED 113620: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 113624: 75 02 jne 113628 <_Objects_Get_name_as_string+0xac> <== NOT EXECUTED 113626: b1 2a mov $0x2a,%cl <== NOT EXECUTED 113628: 88 0e mov %cl,(%esi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11362a: 43 inc %ebx <== NOT EXECUTED 11362b: 46 inc %esi <== NOT EXECUTED 11362c: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 11362f: 73 07 jae 113638 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 113631: 8a 0c 1f mov (%edi,%ebx,1),%cl <== NOT EXECUTED 113634: 84 c9 test %cl,%cl <== NOT EXECUTED 113636: 75 e0 jne 113618 <_Objects_Get_name_as_string+0x9c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 113638: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 11363b: e8 88 ae ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 113640: eb 07 jmp 113649 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return name; 113642: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED } return NULL; /* unreachable path */ } 113649: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11364c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11364f: 5b pop %ebx <== NOT EXECUTED 113650: 5e pop %esi <== NOT EXECUTED 113651: 5f pop %edi <== NOT EXECUTED 113652: c9 leave <== NOT EXECUTED 113653: c3 ret <== NOT EXECUTED 00115a54 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 115a54: 55 push %ebp <== NOT EXECUTED 115a55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115a57: 57 push %edi <== NOT EXECUTED 115a58: 56 push %esi <== NOT EXECUTED 115a59: 53 push %ebx <== NOT EXECUTED 115a5a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115a5d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 115a60: 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) 115a63: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 115a66: 66 85 db test %bx,%bx <== NOT EXECUTED 115a69: 75 03 jne 115a6e <_Objects_Get_next+0x1a> <== NOT EXECUTED next_id = information->minimum_id; 115a6b: 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) 115a6e: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 115a72: 73 13 jae 115a87 <_Objects_Get_next+0x33> <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 115a74: 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; 115a7a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 115a7d: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 115a83: 31 c0 xor %eax,%eax <== NOT EXECUTED 115a85: eb 17 jmp 115a9e <_Objects_Get_next+0x4a> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 115a87: 50 push %eax <== NOT EXECUTED 115a88: 56 push %esi <== NOT EXECUTED 115a89: 53 push %ebx <== NOT EXECUTED 115a8a: 57 push %edi <== NOT EXECUTED 115a8b: e8 78 82 ff ff call 10dd08 <_Objects_Get> <== NOT EXECUTED next_id++; 115a90: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 115a91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115a94: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 115a97: 75 d5 jne 115a6e <_Objects_Get_next+0x1a> <== NOT EXECUTED *next_id_p = next_id; 115a99: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 115a9c: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 115a9e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115aa1: 5b pop %ebx <== NOT EXECUTED 115aa2: 5e pop %esi <== NOT EXECUTED 115aa3: 5f pop %edi <== NOT EXECUTED 115aa4: c9 leave <== NOT EXECUTED 115aa5: c3 ret <== NOT EXECUTED 00114f90 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 114f90: 55 push %ebp <== NOT EXECUTED 114f91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114f93: 53 push %ebx <== NOT EXECUTED 114f94: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 114f97: 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; 114f9a: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 114f9f: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 114fa2: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 114fa5: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 114fa9: 39 d0 cmp %edx,%eax <== NOT EXECUTED 114fab: 72 12 jb 114fbf <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 114fad: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 114fb0: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 114fb3: 85 c0 test %eax,%eax <== NOT EXECUTED 114fb5: 74 08 je 114fbf <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED *location = OBJECTS_LOCAL; 114fb7: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 114fbd: eb 08 jmp 114fc7 <_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; 114fbf: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 114fc5: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 114fc7: 5b pop %ebx <== NOT EXECUTED 114fc8: c9 leave <== NOT EXECUTED 114fc9: c3 ret <== NOT EXECUTED 0010a854 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10a854: 55 push %ebp <== NOT EXECUTED 10a855: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10a857: c9 leave <== NOT EXECUTED 10a858: c3 ret <== NOT EXECUTED 0010b640 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10b640: 55 push %ebp <== NOT EXECUTED 10b641: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b643: 53 push %ebx <== NOT EXECUTED 10b644: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b647: 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 ) 10b64a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b64f: 85 db test %ebx,%ebx <== NOT EXECUTED 10b651: 74 59 je 10b6ac <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b653: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b656: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b658: 75 08 jne 10b662 <_Objects_Id_to_name+0x22> <== NOT EXECUTED 10b65a: a1 44 14 12 00 mov 0x121444,%eax <== NOT EXECUTED 10b65f: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10b662: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b664: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10b667: 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. 10b66a: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10b66d: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b670: 77 35 ja 10b6a7 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 10b672: eb 3d jmp 10b6b1 <_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 ]; 10b674: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b676: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10b679: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10b67c: 85 d2 test %edx,%edx <== NOT EXECUTED 10b67e: 74 27 je 10b6a7 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10b680: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10b684: 75 21 jne 10b6a7 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10b686: 50 push %eax <== NOT EXECUTED 10b687: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b68a: 50 push %eax <== NOT EXECUTED 10b68b: 51 push %ecx <== NOT EXECUTED 10b68c: 52 push %edx <== NOT EXECUTED 10b68d: e8 56 ff ff ff call 10b5e8 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10b692: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b695: 85 c0 test %eax,%eax <== NOT EXECUTED 10b697: 74 0e je 10b6a7 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10b699: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10b69c: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b69e: e8 85 07 00 00 call 10be28 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b6a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b6a5: eb 05 jmp 10b6ac <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10b6a7: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10b6ac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b6af: c9 leave <== NOT EXECUTED 10b6b0: 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 ] ) 10b6b1: 8b 14 95 58 13 12 00 mov 0x121358(,%edx,4),%edx <== NOT EXECUTED 10b6b8: 85 d2 test %edx,%edx <== NOT EXECUTED 10b6ba: 75 b8 jne 10b674 <_Objects_Id_to_name+0x34> <== NOT EXECUTED 10b6bc: eb e9 jmp 10b6a7 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 0010a6f8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10a6f8: 55 push %ebp <== NOT EXECUTED 10a6f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a6fb: 57 push %edi <== NOT EXECUTED 10a6fc: 56 push %esi <== NOT EXECUTED 10a6fd: 53 push %ebx <== NOT EXECUTED 10a6fe: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a701: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a704: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a707: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10a70a: 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; 10a70e: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10a710: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10a714: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10a717: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10a71a: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10a721: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10a728: 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; 10a72e: 8b 04 95 4c d6 11 00 mov 0x11d64c(,%edx,4),%eax <== NOT EXECUTED 10a735: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10a738: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10a73b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a73e: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10a741: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10a744: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10a747: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10a74d: 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; 10a750: c7 47 1c 30 d4 11 00 movl $0x11d430,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10a757: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a75a: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a760: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10a763: 09 da or %ebx,%edx <== NOT EXECUTED 10a765: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a767: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a769: 0f 95 c0 setne %al <== NOT EXECUTED 10a76c: 09 c2 or %eax,%edx <== NOT EXECUTED 10a76e: 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) ) 10a771: 89 f0 mov %esi,%eax <== NOT EXECUTED 10a773: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10a779: 74 06 je 10a781 <_Objects_Initialize_information+0x89> <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10a77b: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10a77e: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10a781: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10a785: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10a788: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10a78b: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10a792: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10a795: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10a798: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a79a: 74 12 je 10a7ae <_Objects_Initialize_information+0xb6> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10a79c: 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 ); 10a7a2: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a7a5: 5b pop %ebx <== NOT EXECUTED 10a7a6: 5e pop %esi <== NOT EXECUTED 10a7a7: 5f pop %edi <== NOT EXECUTED 10a7a8: 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 ); 10a7a9: e9 46 fb ff ff jmp 10a2f4 <_Objects_Extend_information> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a7ae: 5b pop %ebx <== NOT EXECUTED 10a7af: 5e pop %esi <== NOT EXECUTED 10a7b0: 5f pop %edi <== NOT EXECUTED 10a7b1: c9 leave <== NOT EXECUTED 10a7b2: c3 ret <== NOT EXECUTED 00113270 <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 113270: 55 push %ebp <== NOT EXECUTED 113271: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113273: 57 push %edi <== NOT EXECUTED 113274: 56 push %esi <== NOT EXECUTED 113275: 53 push %ebx <== NOT EXECUTED 113276: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113279: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 11327c: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 113281: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 113285: 74 59 je 1132e0 <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( !name ) 113287: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11328b: 74 4e je 1132db <_Objects_Name_to_id_string+0x6b> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 11328d: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 113290: 66 85 c0 test %ax,%ax <== NOT EXECUTED 113293: 74 46 je 1132db <_Objects_Name_to_id_string+0x6b> <== NOT EXECUTED 113295: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 11329a: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 11329d: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1132a0: eb 34 jmp 1132d6 <_Objects_Name_to_id_string+0x66> <== NOT EXECUTED the_object = information->local_table[ index ]; 1132a2: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED 1132a5: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED if ( !the_object ) 1132a8: 85 db test %ebx,%ebx <== NOT EXECUTED 1132aa: 74 29 je 1132d5 <_Objects_Name_to_id_string+0x65> <== NOT EXECUTED continue; if ( !the_object->name.name_p ) 1132ac: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 1132af: 85 d2 test %edx,%edx <== NOT EXECUTED 1132b1: 74 22 je 1132d5 <_Objects_Name_to_id_string+0x65> <== NOT EXECUTED continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 1132b3: 50 push %eax <== NOT EXECUTED 1132b4: 0f b7 47 3a movzwl 0x3a(%edi),%eax <== NOT EXECUTED 1132b8: 50 push %eax <== NOT EXECUTED 1132b9: 52 push %edx <== NOT EXECUTED 1132ba: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1132bd: e8 62 25 00 00 call 115824 <== NOT EXECUTED 1132c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1132c5: 85 c0 test %eax,%eax <== NOT EXECUTED 1132c7: 75 0c jne 1132d5 <_Objects_Name_to_id_string+0x65> <== NOT EXECUTED *id = the_object->id; 1132c9: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1132cc: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1132cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1132d1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1132d3: eb 0b jmp 1132e0 <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 1132d5: 46 inc %esi <== NOT EXECUTED 1132d6: 3b 75 f0 cmp -0x10(%ebp),%esi <== NOT EXECUTED 1132d9: 76 c7 jbe 1132a2 <_Objects_Name_to_id_string+0x32> <== NOT EXECUTED 1132db: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 1132e0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1132e3: 5b pop %ebx <== NOT EXECUTED 1132e4: 5e pop %esi <== NOT EXECUTED 1132e5: 5f pop %edi <== NOT EXECUTED 1132e6: c9 leave <== NOT EXECUTED 1132e7: c3 ret <== NOT EXECUTED 0010a7e8 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10a7e8: 55 push %ebp <== NOT EXECUTED 10a7e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7eb: 57 push %edi <== NOT EXECUTED 10a7ec: 56 push %esi <== NOT EXECUTED 10a7ed: 53 push %ebx <== NOT EXECUTED 10a7ee: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a7f1: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a7f4: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10a7f7: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10a7fa: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10a7ff: 85 f6 test %esi,%esi <== NOT EXECUTED 10a801: 74 49 je 10a84c <_Objects_Name_to_id_u32+0x64> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10a803: 85 db test %ebx,%ebx <== NOT EXECUTED 10a805: 74 40 je 10a847 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10a807: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 10a80a: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10a80d: 74 38 je 10a847 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a80f: 85 d2 test %edx,%edx <== NOT EXECUTED 10a811: 74 28 je 10a83b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a813: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx <== NOT EXECUTED 10a819: 74 20 je 10a83b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a81b: 4a dec %edx <== NOT EXECUTED 10a81c: 75 29 jne 10a847 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a81e: eb 1b jmp 10a83b <_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 ]; 10a820: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED 10a823: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10a826: 85 c0 test %eax,%eax <== NOT EXECUTED 10a828: 74 0e je 10a838 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10a82a: 3b 58 0c cmp 0xc(%eax),%ebx <== NOT EXECUTED 10a82d: 75 09 jne 10a838 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED *id = the_object->id; 10a82f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a832: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10a834: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a836: eb 14 jmp 10a84c <_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++ ) { 10a838: 42 inc %edx <== NOT EXECUTED 10a839: eb 08 jmp 10a843 <_Objects_Name_to_id_u32+0x5b> <== NOT EXECUTED 10a83b: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a840: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED 10a843: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10a845: 76 d9 jbe 10a820 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10a847: 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 } 10a84c: 5b pop %ebx <== NOT EXECUTED 10a84d: 5e pop %esi <== NOT EXECUTED 10a84e: 5f pop %edi <== NOT EXECUTED 10a84f: c9 leave <== NOT EXECUTED 10a850: c3 ret <== NOT EXECUTED 0010a7b4 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10a7b4: 55 push %ebp <== NOT EXECUTED 10a7b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7b7: 53 push %ebx <== NOT EXECUTED 10a7b8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a7bb: 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 ) 10a7be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a7c1: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10a7c5: 74 13 je 10a7da <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10a7c7: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a7ca: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7cc: 74 0c je 10a7da <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10a7ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a7d1: 50 push %eax <== NOT EXECUTED 10a7d2: e8 11 16 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10a7d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10a7da: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10a7e1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a7e4: c9 leave <== NOT EXECUTED 10a7e5: c3 ret <== NOT EXECUTED 0010ae50 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10ae50: 55 push %ebp <== NOT EXECUTED 10ae51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae53: 57 push %edi <== NOT EXECUTED 10ae54: 56 push %esi <== NOT EXECUTED 10ae55: 53 push %ebx <== NOT EXECUTED 10ae56: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ae59: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ae5c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10ae5f: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10ae63: 50 push %eax <== NOT EXECUTED 10ae64: 57 push %edi <== NOT EXECUTED 10ae65: e8 72 63 00 00 call 1111dc <== NOT EXECUTED 10ae6a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10ae6d: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ae6f: 46 inc %esi <== NOT EXECUTED if ( information->is_string ) { 10ae70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae73: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10ae77: 74 56 je 10aecf <_Objects_Set_name+0x7f> <== NOT EXECUTED char *d; d = _Workspace_Allocate( length ); 10ae79: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae7c: 56 push %esi <== NOT EXECUTED 10ae7d: e8 4f 16 00 00 call 10c4d1 <_Workspace_Allocate> <== NOT EXECUTED 10ae82: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10ae84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae87: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae89: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae8b: 0f 84 81 00 00 00 je 10af12 <_Objects_Set_name+0xc2> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10ae91: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ae94: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10ae97: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae99: 74 16 je 10aeb1 <_Objects_Set_name+0x61> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10ae9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae9e: 50 push %eax <== NOT EXECUTED 10ae9f: e8 18 16 00 00 call 10c4bc <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10aea4: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10aea7: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10aeae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10aeb1: 50 push %eax <== NOT EXECUTED 10aeb2: 56 push %esi <== NOT EXECUTED 10aeb3: 57 push %edi <== NOT EXECUTED 10aeb4: 53 push %ebx <== NOT EXECUTED 10aeb5: e8 9a 62 00 00 call 111154 <== NOT EXECUTED d[ length ] = '\0'; 10aeba: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10aebd: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1) <== NOT EXECUTED the_object->name.name_p = d; 10aec2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10aec5: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED 10aec8: b0 01 mov $0x1,%al <== NOT EXECUTED 10aeca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aecd: eb 43 jmp 10af12 <_Objects_Set_name+0xc2> <== NOT EXECUTED } else { the_object->name.name_u32 = _Objects_Build_name( 10aecf: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10aed4: 85 f6 test %esi,%esi <== NOT EXECUTED 10aed6: 74 4e je 10af26 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10aed8: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED 10aedb: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10aede: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10aee1: 74 43 je 10af26 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10aee3: 0f be 5f 01 movsbl 0x1(%edi),%ebx <== NOT EXECUTED 10aee7: c1 e3 10 shl $0x10,%ebx <== NOT EXECUTED 10aeea: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10aeed: 76 2b jbe 10af1a <_Objects_Set_name+0xca> <== NOT EXECUTED 10aeef: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10aef3: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10aef6: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10aefb: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10aefe: 76 04 jbe 10af04 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10af00: 0f be 4f 03 movsbl 0x3(%edi),%ecx <== NOT EXECUTED 10af04: 09 d8 or %ebx,%eax <== NOT EXECUTED 10af06: 09 d0 or %edx,%eax <== NOT EXECUTED 10af08: 09 c8 or %ecx,%eax <== NOT EXECUTED 10af0a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10af0d: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10af10: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10af12: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af15: 5b pop %ebx <== NOT EXECUTED 10af16: 5e pop %esi <== NOT EXECUTED 10af17: 5f pop %edi <== NOT EXECUTED 10af18: c9 leave <== NOT EXECUTED 10af19: 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( 10af1a: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10af1f: ba 00 20 00 00 mov $0x2000,%edx <== NOT EXECUTED 10af24: eb de jmp 10af04 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10af26: bb 00 00 20 00 mov $0x200000,%ebx <== NOT EXECUTED 10af2b: eb ed jmp 10af1a <_Objects_Set_name+0xca> <== NOT EXECUTED 0010a85c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10a85c: 55 push %ebp <== NOT EXECUTED 10a85d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a85f: 57 push %edi <== NOT EXECUTED 10a860: 56 push %esi <== NOT EXECUTED 10a861: 53 push %ebx <== NOT EXECUTED 10a862: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a865: 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 10a868: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a86b: 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; 10a86e: 8b 4e 14 mov 0x14(%esi),%ecx <== NOT EXECUTED 10a871: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a875: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a877: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a879: f7 f1 div %ecx <== NOT EXECUTED 10a87b: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a87d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a87f: eb 7c jmp 10a8fd <_Objects_Shrink_information+0xa1> <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10a881: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax <== NOT EXECUTED 10a888: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10a88b: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a88e: 39 0c 90 cmp %ecx,(%eax,%edx,4) <== NOT EXECUTED 10a891: 75 67 jne 10a8fa <_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; 10a893: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 10a896: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10a899: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10a89c: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 10a89e: 72 1b jb 10a8bb <_Objects_Shrink_information+0x5f> <== NOT EXECUTED 10a8a0: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a8a2: 03 46 14 add 0x14(%esi),%eax <== NOT EXECUTED 10a8a5: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a8a7: 73 12 jae 10a8bb <_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, 10a8a9: 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 ); 10a8ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8ae: 52 push %edx <== NOT EXECUTED 10a8af: e8 20 34 00 00 call 10dcd4 <_Chain_Extract> <== NOT EXECUTED 10a8b4: 89 da mov %ebx,%edx <== NOT EXECUTED 10a8b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8b9: eb 02 jmp 10a8bd <_Objects_Shrink_information+0x61> <== NOT EXECUTED } else { the_object = (Objects_Control *) the_object->Node.next; 10a8bb: 8b 12 mov (%edx),%edx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10a8bd: 85 d2 test %edx,%edx <== NOT EXECUTED 10a8bf: 74 05 je 10a8c6 <_Objects_Shrink_information+0x6a> <== NOT EXECUTED 10a8c1: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10a8c4: 75 d0 jne 10a896 <_Objects_Shrink_information+0x3a> <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10a8c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8c9: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a8cc: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a8cf: ff 34 10 pushl (%eax,%edx,1) <== NOT EXECUTED 10a8d2: e8 11 15 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10a8d7: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a8da: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a8dd: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10a8e4: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a8e7: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10a8ee: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10a8f1: 66 29 46 2c sub %ax,0x2c(%esi) <== NOT EXECUTED 10a8f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8f8: eb 07 jmp 10a901 <_Objects_Shrink_information+0xa5> <== NOT EXECUTED return; } index_base += information->allocation_size; 10a8fa: 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++ ) { 10a8fc: 42 inc %edx <== NOT EXECUTED 10a8fd: 39 da cmp %ebx,%edx <== NOT EXECUTED 10a8ff: 72 80 jb 10a881 <_Objects_Shrink_information+0x25> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10a901: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a904: 5b pop %ebx <== NOT EXECUTED 10a905: 5e pop %esi <== NOT EXECUTED 10a906: 5f pop %edi <== NOT EXECUTED 10a907: c9 leave <== NOT EXECUTED 10a908: c3 ret <== NOT EXECUTED 00109818 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 109818: 55 push %ebp <== NOT EXECUTED 109819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10981b: 53 push %ebx <== NOT EXECUTED 10981c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 10981f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109822: 8b 58 44 mov 0x44(%eax),%ebx <== NOT EXECUTED if ( !api_configuration ) 109825: 85 db test %ebx,%ebx <== NOT EXECUTED 109827: 75 05 jne 10982e <_POSIX_API_Initialize+0x16> <== NOT EXECUTED 109829: bb 34 72 11 00 mov $0x117234,%ebx <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 10982e: c7 05 58 d6 11 00 2c movl $0x11db2c,0x11d658 <== NOT EXECUTED 109835: db 11 00 <== NOT EXECUTED _POSIX_signals_Manager_Initialization( 109838: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10983b: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10983e: e8 b1 3b 00 00 call 10d3f4 <_POSIX_signals_Manager_Initialization> <== NOT EXECUTED api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 109843: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109846: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 109849: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10984c: ff 33 pushl (%ebx) <== NOT EXECUTED 10984e: e8 23 3d 00 00 call 10d576 <_POSIX_Threads_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 109853: 58 pop %eax <== NOT EXECUTED 109854: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 109857: e8 88 3a 00 00 call 10d2e4 <_POSIX_Condition_variables_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 10985c: 58 pop %eax <== NOT EXECUTED 10985d: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 109860: e8 a7 3a 00 00 call 10d30c <_POSIX_Key_Manager_initialization> <== NOT EXECUTED _POSIX_Mutex_Manager_initialization( 109865: 58 pop %eax <== NOT EXECUTED 109866: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 109869: e8 0e 3b 00 00 call 10d37c <_POSIX_Mutex_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 10986e: 58 pop %eax <== NOT EXECUTED 10986f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109872: e8 bd 3a 00 00 call 10d334 <_POSIX_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 109877: 58 pop %eax <== NOT EXECUTED 109878: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10987b: e8 fc 3f 00 00 call 10d87c <_POSIX_Semaphore_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 109880: 59 pop %ecx <== NOT EXECUTED 109881: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109884: e8 cb 3f 00 00 call 10d854 <_POSIX_Timer_Manager_initialization> <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 109889: 5a pop %edx <== NOT EXECUTED 10988a: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10988d: e8 12 3b 00 00 call 10d3a4 <_POSIX_Barrier_Manager_initialization> <== NOT EXECUTED _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 109892: 58 pop %eax <== NOT EXECUTED 109893: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 109896: e8 31 3b 00 00 call 10d3cc <_POSIX_RWLock_Manager_initialization> <== NOT EXECUTED _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 10989b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10989e: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1098a1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1098a4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1098a7: c9 leave <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 1098a8: e9 8f 3c 00 00 jmp 10d53c <_POSIX_Spinlock_Manager_initialization> <== NOT EXECUTED 0010ab18 <_POSIX_Absolute_timeout_to_ticks>: */ POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks( const struct timespec *abstime, Watchdog_Interval *ticks_out ) { 10ab18: 55 push %ebp <== NOT EXECUTED 10ab19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab1b: 57 push %edi <== NOT EXECUTED 10ab1c: 56 push %esi <== NOT EXECUTED 10ab1d: 53 push %ebx <== NOT EXECUTED 10ab1e: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10ab21: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED /* * Make sure there is always a value returned. */ *ticks_out = 0; 10ab24: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ab27: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED /* * Is the absolute time even valid? */ if ( !_Timespec_Is_valid(abstime) ) 10ab2d: 57 push %edi <== NOT EXECUTED 10ab2e: e8 21 39 00 00 call 10e454 <_Timespec_Is_valid> <== NOT EXECUTED 10ab33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab36: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ab38: 84 c0 test %al,%al <== NOT EXECUTED 10ab3a: 74 45 je 10ab81 <_POSIX_Absolute_timeout_to_ticks+0x69> <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_INVALID; /* * Is the absolute time in the past? */ _TOD_Get( ¤t_time ); 10ab3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab3f: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED 10ab42: 56 push %esi <== NOT EXECUTED 10ab43: e8 08 1e 00 00 call 10c950 <_TOD_Get> <== NOT EXECUTED if ( _Timespec_Less_than( abstime, ¤t_time ) ) 10ab48: 5a pop %edx <== NOT EXECUTED 10ab49: 59 pop %ecx <== NOT EXECUTED 10ab4a: 56 push %esi <== NOT EXECUTED 10ab4b: 57 push %edi <== NOT EXECUTED 10ab4c: e8 27 39 00 00 call 10e478 <_Timespec_Less_than> <== NOT EXECUTED 10ab51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab54: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ab59: 84 c0 test %al,%al <== NOT EXECUTED 10ab5b: 75 24 jne 10ab81 <_POSIX_Absolute_timeout_to_ticks+0x69> <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; /* * How long until the requested absolute time? */ _Timespec_Subtract( ¤t_time, abstime, &difference ); 10ab5d: 50 push %eax <== NOT EXECUTED 10ab5e: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10ab61: 53 push %ebx <== NOT EXECUTED 10ab62: 57 push %edi <== NOT EXECUTED 10ab63: 56 push %esi <== NOT EXECUTED 10ab64: e8 37 39 00 00 call 10e4a0 <_Timespec_Subtract> <== NOT EXECUTED /* * Internally the SuperCore uses ticks, so convert to them. */ *ticks_out = _Timespec_To_ticks( &difference ); 10ab69: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ab6c: e8 67 39 00 00 call 10e4d8 <_Timespec_To_ticks> <== NOT EXECUTED 10ab71: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ab74: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If the difference was 0, then the future is now. It is so bright * we better wear shades. */ if ( !*ticks_out ) 10ab76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab79: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10ab7c: 19 d2 sbb %edx,%edx <== NOT EXECUTED 10ab7e: 83 c2 03 add $0x3,%edx <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10ab81: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ab83: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ab86: 5b pop %ebx <== NOT EXECUTED 10ab87: 5e pop %esi <== NOT EXECUTED 10ab88: 5f pop %edi <== NOT EXECUTED 10ab89: c9 leave <== NOT EXECUTED 10ab8a: c3 ret <== NOT EXECUTED 0010d3a4 <_POSIX_Barrier_Manager_initialization>: */ void _POSIX_Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10d3a4: 55 push %ebp <== NOT EXECUTED 10d3a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d3aa: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d3af: 6a 01 push $0x1 <== NOT EXECUTED 10d3b1: 6a 5c push $0x5c <== NOT EXECUTED 10d3b3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3b6: 6a 0a push $0xa <== NOT EXECUTED 10d3b8: 6a 03 push $0x3 <== NOT EXECUTED 10d3ba: 68 68 da 11 00 push $0x11da68 <== NOT EXECUTED 10d3bf: e8 34 d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d3c4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d3c7: c9 leave <== NOT EXECUTED 10d3c8: c3 ret <== NOT EXECUTED 0010e5e8 <_POSIX_Barrier_Translate_core_barrier_return_code>: int _POSIX_Barrier_Translate_core_barrier_return_code( CORE_barrier_Status the_barrier_status ) { 10e5e8: 55 push %ebp <== NOT EXECUTED 10e5e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e5ee: 8b 04 85 ac 8b 11 00 mov 0x118bac(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return EINVAL; #endif return _POSIX_Barrier_Return_codes[the_barrier_status]; } 10e5f5: c9 leave <== NOT EXECUTED 10e5f6: c3 ret <== NOT EXECUTED 00109a24 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 109a24: 55 push %ebp <== NOT EXECUTED 109a25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a27: 56 push %esi <== NOT EXECUTED 109a28: 53 push %ebx <== NOT EXECUTED 109a29: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109a2c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 109a2f: 85 db test %ebx,%ebx <== NOT EXECUTED 109a31: 74 16 je 109a49 <_POSIX_Condition_variables_Get+0x25> <== NOT EXECUTED *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 109a33: 83 3b ff cmpl $0xffffffff,(%ebx) <== NOT EXECUTED 109a36: 75 1b jne 109a53 <_POSIX_Condition_variables_Get+0x2f> <== NOT EXECUTED /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 109a38: 52 push %edx <== NOT EXECUTED 109a39: 52 push %edx <== NOT EXECUTED 109a3a: 6a 00 push $0x0 <== NOT EXECUTED 109a3c: 53 push %ebx <== NOT EXECUTED 109a3d: e8 2a 00 00 00 call 109a6c <== NOT EXECUTED if ( status ) { 109a42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a45: 85 c0 test %eax,%eax <== NOT EXECUTED 109a47: 74 0a je 109a53 <_POSIX_Condition_variables_Get+0x2f> <== NOT EXECUTED *location = OBJECTS_ERROR; 109a49: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 109a4f: 31 c0 xor %eax,%eax <== NOT EXECUTED 109a51: eb 11 jmp 109a64 <_POSIX_Condition_variables_Get+0x40> <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 109a53: 50 push %eax <== NOT EXECUTED 109a54: 56 push %esi <== NOT EXECUTED 109a55: ff 33 pushl (%ebx) <== NOT EXECUTED 109a57: 68 b4 13 12 00 push $0x1213b4 <== NOT EXECUTED 109a5c: e8 3b 29 00 00 call 10c39c <_Objects_Get> <== NOT EXECUTED 109a61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Condition_variables_Information, *id, location ); } 109a64: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109a67: 5b pop %ebx <== NOT EXECUTED 109a68: 5e pop %esi <== NOT EXECUTED 109a69: c9 leave <== NOT EXECUTED 109a6a: c3 ret <== NOT EXECUTED 0010d2e4 <_POSIX_Condition_variables_Manager_initialization>: */ void _POSIX_Condition_variables_Manager_initialization( uint32_t maximum_condition_variables ) { 10d2e4: 55 push %ebp <== NOT EXECUTED 10d2e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2ea: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d2ef: 6a 01 push $0x1 <== NOT EXECUTED 10d2f1: 6a 58 push $0x58 <== NOT EXECUTED 10d2f3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d2f6: 6a 08 push $0x8 <== NOT EXECUTED 10d2f8: 6a 03 push $0x3 <== NOT EXECUTED 10d2fa: 68 ec da 11 00 push $0x11daec <== NOT EXECUTED 10d2ff: e8 f4 d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d304: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d307: c9 leave <== NOT EXECUTED 10d308: c3 ret <== NOT EXECUTED 00109b1c <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, bool is_broadcast ) { 109b1c: 55 push %ebp <== NOT EXECUTED 109b1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b1f: 56 push %esi <== NOT EXECUTED 109b20: 53 push %ebx <== NOT EXECUTED 109b21: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 109b24: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 109b27: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 109b2a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109b2d: 50 push %eax <== NOT EXECUTED 109b2e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109b31: e8 ee fe ff ff call 109a24 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 109b36: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 109b38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b3b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 109b40: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 109b44: 75 2b jne 109b71 <_POSIX_Condition_variables_Signal_support+0x55> <== NOT EXECUTED case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 109b46: 8d 73 18 lea 0x18(%ebx),%esi <== NOT EXECUTED 109b49: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b4c: 56 push %esi <== NOT EXECUTED 109b4d: e8 42 33 00 00 call 10ce94 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( !the_thread ) 109b52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b55: 85 c0 test %eax,%eax <== NOT EXECUTED 109b57: 75 07 jne 109b60 <_POSIX_Condition_variables_Signal_support+0x44> <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 109b59: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED } while ( is_broadcast && the_thread ); 109b60: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 109b64: 74 04 je 109b6a <_POSIX_Condition_variables_Signal_support+0x4e> <== NOT EXECUTED 109b66: 85 c0 test %eax,%eax <== NOT EXECUTED 109b68: 75 df jne 109b49 <_POSIX_Condition_variables_Signal_support+0x2d> <== NOT EXECUTED _Thread_Enable_dispatch(); 109b6a: e8 ed 2f 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109b6f: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109b71: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109b74: 5b pop %ebx <== NOT EXECUTED 109b75: 5e pop %esi <== NOT EXECUTED 109b76: c9 leave <== NOT EXECUTED 109b77: c3 ret <== NOT EXECUTED 00109bd4 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 109bd4: 55 push %ebp <== NOT EXECUTED 109bd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109bd7: 57 push %edi <== NOT EXECUTED 109bd8: 56 push %esi <== NOT EXECUTED 109bd9: 53 push %ebx <== NOT EXECUTED 109bda: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 109bdd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109be0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109be3: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED 109be6: 88 45 e3 mov %al,-0x1d(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 109be9: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 109bec: 53 push %ebx <== NOT EXECUTED 109bed: 56 push %esi <== NOT EXECUTED 109bee: e8 82 01 00 00 call 109d75 <_POSIX_Mutex_Get> <== NOT EXECUTED 109bf3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109bf6: 85 c0 test %eax,%eax <== NOT EXECUTED 109bf8: 0f 84 af 00 00 00 je 109cad <_POSIX_Condition_variables_Wait_support+0xd9> <== NOT EXECUTED 109bfe: a1 40 0f 12 00 mov 0x120f40,%eax <== NOT EXECUTED 109c03: 48 dec %eax <== NOT EXECUTED 109c04: a3 40 0f 12 00 mov %eax,0x120f40 <== NOT EXECUTED return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 109c09: 52 push %edx <== NOT EXECUTED 109c0a: 52 push %edx <== NOT EXECUTED 109c0b: 53 push %ebx <== NOT EXECUTED 109c0c: 57 push %edi <== NOT EXECUTED 109c0d: e8 12 fe ff ff call 109a24 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 109c12: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 109c14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c17: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109c1b: 0f 85 8c 00 00 00 jne 109cad <_POSIX_Condition_variables_Wait_support+0xd9> <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 109c21: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 109c24: 85 c0 test %eax,%eax <== NOT EXECUTED 109c26: 74 0b je 109c33 <_POSIX_Condition_variables_Wait_support+0x5f> <== NOT EXECUTED 109c28: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 109c2a: 74 07 je 109c33 <_POSIX_Condition_variables_Wait_support+0x5f> <== NOT EXECUTED _Thread_Enable_dispatch(); 109c2c: e8 2b 2f 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109c31: eb 7a jmp 109cad <_POSIX_Condition_variables_Wait_support+0xd9> <== NOT EXECUTED return EINVAL; } (void) pthread_mutex_unlock( mutex ); 109c33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c36: 56 push %esi <== NOT EXECUTED 109c37: e8 10 03 00 00 call 109f4c <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 109c3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c3f: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) <== NOT EXECUTED 109c43: 75 4e jne 109c93 <_POSIX_Condition_variables_Wait_support+0xbf> <== NOT EXECUTED the_cond->Mutex = *mutex; 109c45: 8b 06 mov (%esi),%eax <== NOT EXECUTED 109c47: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109c4a: c7 43 48 01 00 00 00 movl $0x1,0x48(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 109c51: 8b 15 00 10 12 00 mov 0x121000,%edx <== NOT EXECUTED 109c57: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 109c5e: 8d 4b 18 lea 0x18(%ebx),%ecx <== NOT EXECUTED 109c61: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED _Thread_Executing->Wait.id = *cond; 109c64: 8b 07 mov (%edi),%eax <== NOT EXECUTED 109c66: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 109c69: 50 push %eax <== NOT EXECUTED 109c6a: 68 fc d2 10 00 push $0x10d2fc <== NOT EXECUTED 109c6f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109c72: 51 push %ecx <== NOT EXECUTED 109c73: e8 34 33 00 00 call 10cfac <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 109c78: e8 df 2e 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 109c7d: a1 00 10 12 00 mov 0x121000,%eax <== NOT EXECUTED 109c82: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED if ( status && status != ETIMEDOUT ) 109c85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c88: 85 db test %ebx,%ebx <== NOT EXECUTED 109c8a: 74 11 je 109c9d <_POSIX_Condition_variables_Wait_support+0xc9> <== NOT EXECUTED 109c8c: 83 fb 74 cmp $0x74,%ebx <== NOT EXECUTED 109c8f: 75 21 jne 109cb2 <_POSIX_Condition_variables_Wait_support+0xde> <== NOT EXECUTED 109c91: eb 0a jmp 109c9d <_POSIX_Condition_variables_Wait_support+0xc9> <== NOT EXECUTED return status; } else { _Thread_Enable_dispatch(); 109c93: e8 c4 2e 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109c98: bb 74 00 00 00 mov $0x74,%ebx <== NOT EXECUTED /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 109c9d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ca0: 56 push %esi <== NOT EXECUTED 109ca1: e8 26 02 00 00 call 109ecc <== NOT EXECUTED if ( mutex_status ) 109ca6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ca9: 85 c0 test %eax,%eax <== NOT EXECUTED 109cab: 74 05 je 109cb2 <_POSIX_Condition_variables_Wait_support+0xde> <== NOT EXECUTED 109cad: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109cb2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109cb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109cb7: 5b pop %ebx <== NOT EXECUTED 109cb8: 5e pop %esi <== NOT EXECUTED 109cb9: 5f pop %edi <== NOT EXECUTED 109cba: c9 leave <== NOT EXECUTED 109cbb: c3 ret <== NOT EXECUTED 0010d30c <_POSIX_Key_Manager_initialization>: */ void _POSIX_Key_Manager_initialization( uint32_t maximum_keys ) { 10d30c: 55 push %ebp <== NOT EXECUTED 10d30d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d30f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d312: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d317: 6a 01 push $0x1 <== NOT EXECUTED 10d319: 6a 2c push $0x2c <== NOT EXECUTED 10d31b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d31e: 6a 02 push $0x2 <== NOT EXECUTED 10d320: 6a 03 push $0x3 <== NOT EXECUTED 10d322: 68 ac da 11 00 push $0x11daac <== NOT EXECUTED 10d327: e8 cc d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d32c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d32f: c9 leave <== NOT EXECUTED 10d330: c3 ret <== NOT EXECUTED 0010e9c8 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 10e9c8: 55 push %ebp <== NOT EXECUTED 10e9c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9cb: 57 push %edi <== NOT EXECUTED 10e9cc: 56 push %esi <== NOT EXECUTED 10e9cd: 53 push %ebx <== NOT EXECUTED 10e9ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t iterations; bool are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 10e9d1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e9d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10e9d7: 89 c2 mov %eax,%edx <== NOT EXECUTED 10e9d9: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10e9dc: 83 e2 07 and $0x7,%edx <== NOT EXECUTED the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 10e9df: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10e9e4: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10e9e7: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10e9ea: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10e9f1: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 10e9f4: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 10e9f7: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 10e9fc: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10ea01: eb 49 jmp 10ea4c <_POSIX_Keys_Run_destructors+0x84> <== NOT EXECUTED are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { the_key = (POSIX_Keys_Control *) 10ea03: a1 c8 da 11 00 mov 0x11dac8,%eax <== NOT EXECUTED 10ea08: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 10ea0b: 85 db test %ebx,%ebx <== NOT EXECUTED 10ea0d: 74 3c je 10ea4b <_POSIX_Keys_Run_destructors+0x83> <== NOT EXECUTED 10ea0f: 80 7b 10 00 cmpb $0x0,0x10(%ebx) <== NOT EXECUTED 10ea13: 74 36 je 10ea4b <_POSIX_Keys_Run_destructors+0x83> <== NOT EXECUTED 10ea15: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10ea18: 85 d2 test %edx,%edx <== NOT EXECUTED 10ea1a: 74 2f je 10ea4b <_POSIX_Keys_Run_destructors+0x83> <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 10ea1c: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 10ea1f: 8b 44 8b 08 mov 0x8(%ebx,%ecx,4),%eax <== NOT EXECUTED 10ea23: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10ea26: 8b 04 08 mov (%eax,%ecx,1),%eax <== NOT EXECUTED if ( value ) { 10ea29: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea2b: 74 1e je 10ea4b <_POSIX_Keys_Run_destructors+0x83> <== NOT EXECUTED (*the_key->destructor)( value ); 10ea2d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea30: 50 push %eax <== NOT EXECUTED 10ea31: ff d2 call *%edx <== NOT EXECUTED if ( the_key->Values[ thread_api ][ thread_index ] ) 10ea33: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10ea36: 8b 44 93 08 mov 0x8(%ebx,%edx,4),%eax <== NOT EXECUTED 10ea3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea3d: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10ea40: 83 3c 08 00 cmpl $0x0,(%eax,%ecx,1) <== NOT EXECUTED 10ea44: 0f 94 c0 sete %al <== NOT EXECUTED 10ea47: f7 d8 neg %eax <== NOT EXECUTED 10ea49: 21 c7 and %eax,%edi <== NOT EXECUTED for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 10ea4b: 46 inc %esi <== NOT EXECUTED 10ea4c: 0f b7 05 bc da 11 00 movzwl 0x11dabc,%eax <== NOT EXECUTED 10ea53: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ea55: 76 ac jbe 10ea03 <_POSIX_Keys_Run_destructors+0x3b> <== NOT EXECUTED are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 10ea57: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ea59: 84 c0 test %al,%al <== NOT EXECUTED 10ea5b: 75 09 jne 10ea66 <_POSIX_Keys_Run_destructors+0x9e> <== NOT EXECUTED return; iterations++; 10ea5d: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED * loop. It seems rude to unnecessarily lock up a system. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS ) 10ea60: 83 7d f0 04 cmpl $0x4,-0x10(%ebp) <== NOT EXECUTED 10ea64: 75 91 jne 10e9f7 <_POSIX_Keys_Run_destructors+0x2f> <== NOT EXECUTED return; } } 10ea66: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea69: 5b pop %ebx <== NOT EXECUTED 10ea6a: 5e pop %esi <== NOT EXECUTED 10ea6b: 5f pop %edi <== NOT EXECUTED 10ea6c: c9 leave <== NOT EXECUTED 10ea6d: c3 ret <== NOT EXECUTED 00112384 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 112384: 55 push %ebp <== NOT EXECUTED 112385: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112387: 57 push %edi <== NOT EXECUTED 112388: 56 push %esi <== NOT EXECUTED 112389: 53 push %ebx <== NOT EXECUTED 11238a: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 11238d: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 112390: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 112395: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112398: e8 bb 35 00 00 call 115958 <== NOT EXECUTED 11239d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( n > NAME_MAX ) 11239f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1123a2: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED 1123a7: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED 1123ad: 0f 87 34 01 00 00 ja 1124e7 <_POSIX_Message_queue_Create_support+0x163> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1123b3: a1 38 62 12 00 mov 0x126238,%eax <== NOT EXECUTED 1123b8: 40 inc %eax <== NOT EXECUTED 1123b9: a3 38 62 12 00 mov %eax,0x126238 <== NOT EXECUTED * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 1123be: 85 f6 test %esi,%esi <== NOT EXECUTED 1123c0: 75 0d jne 1123cf <_POSIX_Message_queue_Create_support+0x4b> <== NOT EXECUTED 1123c2: c7 45 e0 10 00 00 00 movl $0x10,-0x20(%ebp) <== NOT EXECUTED 1123c9: 66 be 0a 00 mov $0xa,%si <== NOT EXECUTED 1123cd: eb 31 jmp 112400 <_POSIX_Message_queue_Create_support+0x7c> <== NOT EXECUTED attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1123cf: 83 7e 04 00 cmpl $0x0,0x4(%esi) <== NOT EXECUTED 1123d3: 7e 06 jle 1123db <_POSIX_Message_queue_Create_support+0x57> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1123d5: 83 7e 08 00 cmpl $0x0,0x8(%esi) <== NOT EXECUTED 1123d9: 7f 12 jg 1123ed <_POSIX_Message_queue_Create_support+0x69> <== NOT EXECUTED _Thread_Enable_dispatch(); 1123db: e8 28 d9 ff ff call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 1123e0: e8 cb 1f 00 00 call 1143b0 <__errno> <== NOT EXECUTED 1123e5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1123eb: eb 39 jmp 112426 <_POSIX_Message_queue_Create_support+0xa2> <== NOT EXECUTED } attr = *attr_ptr; 1123ed: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 1123f0: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1123f5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1123f7: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1123fa: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1123fd: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus extern "C" { 112400: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112403: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 112408: e8 ab cc ff ff call 10f0b8 <_Objects_Allocate> <== NOT EXECUTED 11240d: 89 c7 mov %eax,%edi <== NOT EXECUTED } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 11240f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112412: 85 c0 test %eax,%eax <== NOT EXECUTED 112414: 75 18 jne 11242e <_POSIX_Message_queue_Create_support+0xaa> <== NOT EXECUTED _Thread_Enable_dispatch(); 112416: e8 ed d8 ff ff call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 11241b: e8 90 1f 00 00 call 1143b0 <__errno> <== NOT EXECUTED 112420: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 112426: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 112429: e9 b9 00 00 00 jmp 1124e7 <_POSIX_Message_queue_Create_support+0x163> <== NOT EXECUTED } the_mq->process_shared = pshared; 11242e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112431: 89 47 10 mov %eax,0x10(%edi) <== NOT EXECUTED the_mq->named = TRUE; 112434: c6 47 14 01 movb $0x1,0x14(%edi) <== NOT EXECUTED the_mq->open_count = 1; 112438: c7 47 18 01 00 00 00 movl $0x1,0x18(%edi) <== NOT EXECUTED the_mq->linked = TRUE; 11243f: c6 47 15 01 movb $0x1,0x15(%edi) <== NOT EXECUTED /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 112443: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112446: 53 push %ebx <== NOT EXECUTED 112447: e8 35 e9 ff ff call 110d81 <_Workspace_Allocate> <== NOT EXECUTED 11244c: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (!name) { 11244e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112451: 85 c0 test %eax,%eax <== NOT EXECUTED 112453: 75 1f jne 112474 <_POSIX_Message_queue_Create_support+0xf0> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 112455: 51 push %ecx <== NOT EXECUTED 112456: 51 push %ecx <== NOT EXECUTED 112457: 57 push %edi <== NOT EXECUTED 112458: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 11245d: e8 66 cf ff ff call 10f3c8 <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 112462: e8 a1 d8 ff ff call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 112467: e8 44 1f 00 00 call 1143b0 <__errno> <== NOT EXECUTED 11246c: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 112472: eb 4f jmp 1124c3 <_POSIX_Message_queue_Create_support+0x13f> <== NOT EXECUTED } strcpy( name, name_arg ); 112474: 52 push %edx <== NOT EXECUTED 112475: 52 push %edx <== NOT EXECUTED 112476: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112479: 50 push %eax <== NOT EXECUTED 11247a: e8 bd 30 00 00 call 11553c <== NOT EXECUTED * Note that thread blocking discipline should be based on the * current scheduling policy. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 11247f: c7 47 5c 00 00 00 00 movl $0x0,0x5c(%edi) <== NOT EXECUTED if ( ! _CORE_message_queue_Initialize( 112486: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 112489: 56 push %esi <== NOT EXECUTED 11248a: 8d 47 5c lea 0x5c(%edi),%eax <== NOT EXECUTED 11248d: 50 push %eax <== NOT EXECUTED 11248e: 8d 47 1c lea 0x1c(%edi),%eax <== NOT EXECUTED 112491: 50 push %eax <== NOT EXECUTED 112492: e8 d1 09 00 00 call 112e68 <_CORE_message_queue_Initialize> <== NOT EXECUTED 112497: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11249a: 84 c0 test %al,%al <== NOT EXECUTED 11249c: 75 2d jne 1124cb <_POSIX_Message_queue_Create_support+0x147> <== NOT EXECUTED 11249e: 50 push %eax <== NOT EXECUTED 11249f: 50 push %eax <== NOT EXECUTED 1124a0: 57 push %edi <== NOT EXECUTED 1124a1: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 1124a6: e8 1d cf ff ff call 10f3c8 <_Objects_Free> <== NOT EXECUTED attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 1124ab: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1124ae: e8 b9 e8 ff ff call 110d6c <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 1124b3: e8 50 d8 ff ff call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1124b8: e8 f3 1e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 1124bd: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1124c3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1124c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1124c9: eb 1c jmp 1124e7 <_POSIX_Message_queue_Create_support+0x163> <== NOT EXECUTED 1124cb: 0f b7 47 08 movzwl 0x8(%edi),%eax <== NOT EXECUTED 1124cf: 8b 15 c4 65 12 00 mov 0x1265c4,%edx <== NOT EXECUTED 1124d5: 89 3c 82 mov %edi,(%edx,%eax,4) <== NOT EXECUTED 1124d8: 89 5f 0c mov %ebx,0xc(%edi) <== NOT EXECUTED &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 1124db: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1124de: 89 38 mov %edi,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1124e0: e8 23 d8 ff ff call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 1124e5: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1124e7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1124ea: 5b pop %ebx <== NOT EXECUTED 1124eb: 5e pop %esi <== NOT EXECUTED 1124ec: 5f pop %edi <== NOT EXECUTED 1124ed: c9 leave <== NOT EXECUTED 1124ee: c3 ret <== NOT EXECUTED 0010c4d0 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 10c4d0: 55 push %ebp <== NOT EXECUTED 10c4d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c4d3: 53 push %ebx <== NOT EXECUTED 10c4d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c4d7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_mq->linked && !the_mq->open_count ) { 10c4da: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 10c4de: 75 46 jne 10c526 <_POSIX_Message_queue_Delete+0x56> <== NOT EXECUTED 10c4e0: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10c4e4: 75 40 jne 10c526 <_POSIX_Message_queue_Delete+0x56> <== NOT EXECUTED /* the name memory may have been freed by unlink. */ Objects_Control *the_object = &the_mq->Object; if ( the_object->name.name_p ) 10c4e6: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10c4e9: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4eb: 74 0c je 10c4f9 <_POSIX_Message_queue_Delete+0x29> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10c4ed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4f0: 50 push %eax <== NOT EXECUTED 10c4f1: e8 76 48 00 00 call 110d6c <_Workspace_Free> <== NOT EXECUTED 10c4f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Close( &_POSIX_Message_queue_Information, the_object ); 10c4f9: 51 push %ecx <== NOT EXECUTED 10c4fa: 51 push %ecx <== NOT EXECUTED 10c4fb: 53 push %ebx <== NOT EXECUTED 10c4fc: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 10c501: e8 26 2c 00 00 call 10f12c <_Objects_Close> <== NOT EXECUTED _CORE_message_queue_Close( 10c506: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c509: 6a 05 push $0x5 <== NOT EXECUTED 10c50b: 6a 00 push $0x0 <== NOT EXECUTED 10c50d: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10c510: 50 push %eax <== NOT EXECUTED 10c511: e8 32 22 00 00 call 10e748 <_CORE_message_queue_Close> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10c516: 58 pop %eax <== NOT EXECUTED 10c517: 5a pop %edx <== NOT EXECUTED 10c518: 53 push %ebx <== NOT EXECUTED 10c519: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 10c51e: e8 a5 2e 00 00 call 10f3c8 <_Objects_Free> <== NOT EXECUTED 10c523: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _POSIX_Message_queue_Free( the_mq ); } } 10c526: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c529: c9 leave <== NOT EXECUTED 10c52a: c3 ret <== NOT EXECUTED 0010d334 <_POSIX_Message_queue_Manager_initialization>: */ void _POSIX_Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10d334: 55 push %ebp <== NOT EXECUTED 10d335: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d337: 53 push %ebx <== NOT EXECUTED 10d338: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d33b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Objects_Initialize_information( 10d33e: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d343: 6a 01 push $0x1 <== NOT EXECUTED 10d345: 68 a4 00 00 00 push $0xa4 <== NOT EXECUTED 10d34a: 53 push %ebx <== NOT EXECUTED 10d34b: 6a 05 push $0x5 <== NOT EXECUTED 10d34d: 6a 03 push $0x3 <== NOT EXECUTED 10d34f: 68 e8 d9 11 00 push $0x11d9e8 <== NOT EXECUTED 10d354: e8 9f d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); _Objects_Initialize_information( 10d359: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED 10d35c: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d361: 6a 01 push $0x1 <== NOT EXECUTED 10d363: 6a 18 push $0x18 <== NOT EXECUTED 10d365: 53 push %ebx <== NOT EXECUTED 10d366: 6a 04 push $0x4 <== NOT EXECUTED 10d368: 6a 03 push $0x3 <== NOT EXECUTED 10d36a: 68 64 db 11 00 push $0x11db64 <== NOT EXECUTED 10d36f: e8 84 d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d374: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d377: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d37a: c9 leave <== NOT EXECUTED 10d37b: c3 ret <== NOT EXECUTED 001124f0 <_POSIX_Message_queue_Name_to_id>: int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 1124f0: 55 push %ebp <== NOT EXECUTED 1124f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1124f3: 57 push %edi <== NOT EXECUTED 1124f4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1124f7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 1124fa: 85 d2 test %edx,%edx <== NOT EXECUTED 1124fc: 74 3c je 11253a <_POSIX_Message_queue_Name_to_id+0x4a> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 1124fe: 80 3a 00 cmpb $0x0,(%edx) <== NOT EXECUTED 112501: 74 37 je 11253a <_POSIX_Message_queue_Name_to_id+0x4a> <== NOT EXECUTED return EINVAL; if( strlen(name) > PATH_MAX ) 112503: 31 c0 xor %eax,%eax <== NOT EXECUTED 112505: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 112508: 89 d7 mov %edx,%edi <== NOT EXECUTED 11250a: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11250c: f7 d1 not %ecx <== NOT EXECUTED 11250e: 49 dec %ecx <== NOT EXECUTED 11250f: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED 112514: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 11251a: 77 23 ja 11253f <_POSIX_Message_queue_Name_to_id+0x4f> <== NOT EXECUTED return ENAMETOOLONG; status = _Objects_Name_to_id_string( 11251c: 50 push %eax <== NOT EXECUTED 11251d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112520: 52 push %edx <== NOT EXECUTED 112521: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 112526: e8 45 0d 00 00 call 113270 <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Message_queue_Information, name, id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11252b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11252e: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 112531: 19 c0 sbb %eax,%eax <== NOT EXECUTED 112533: f7 d0 not %eax <== NOT EXECUTED 112535: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 112538: eb 05 jmp 11253f <_POSIX_Message_queue_Name_to_id+0x4f> <== NOT EXECUTED 11253a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 11253f: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 112542: c9 leave <== NOT EXECUTED 112543: c3 ret <== NOT EXECUTED 0010c631 <_POSIX_Message_queue_Notify_handler>: */ void _POSIX_Message_queue_Notify_handler( void *user_data ) { 10c631: 55 push %ebp <== NOT EXECUTED 10c632: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c634: 56 push %esi <== NOT EXECUTED 10c635: 53 push %ebx <== NOT EXECUTED 10c636: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; the_mq = user_data; kill( getpid(), the_mq->notification.sigev_signo ); 10c639: 8b b3 94 00 00 00 mov 0x94(%ebx),%esi <== NOT EXECUTED 10c63f: e8 30 57 00 00 call 111d74 <== NOT EXECUTED 10c644: 52 push %edx <== NOT EXECUTED 10c645: 52 push %edx <== NOT EXECUTED 10c646: 56 push %esi <== NOT EXECUTED 10c647: 50 push %eax <== NOT EXECUTED 10c648: e8 1f 5d 00 00 call 11236c <== NOT EXECUTED 10c64d: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) <== NOT EXECUTED 10c654: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) <== NOT EXECUTED 10c65b: 00 00 00 <== NOT EXECUTED 10c65e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } 10c661: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c664: 5b pop %ebx <== NOT EXECUTED 10c665: 5e pop %esi <== NOT EXECUTED 10c666: c9 leave <== NOT EXECUTED 10c667: c3 ret <== NOT EXECUTED 0010c7f4 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10c7f4: 55 push %ebp <== NOT EXECUTED 10c7f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7f7: 57 push %edi <== NOT EXECUTED 10c7f8: 56 push %esi <== NOT EXECUTED 10c7f9: 53 push %ebx <== NOT EXECUTED 10c7fa: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10c7fd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c800: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10c803: 8a 5d 18 mov 0x18(%ebp),%bl <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10c806: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c809: 50 push %eax <== NOT EXECUTED 10c80a: 57 push %edi <== NOT EXECUTED 10c80b: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c810: e8 e7 2c 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED 10c815: 89 c1 mov %eax,%ecx <== NOT EXECUTED Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c817: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c81a: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10c81e: 0f 85 b0 00 00 00 jne 10c8d4 <_POSIX_Message_queue_Receive_support+0xe0> <== NOT EXECUTED case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10c824: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10c827: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c829: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10c82c: 48 dec %eax <== NOT EXECUTED 10c82d: 75 0a jne 10c839 <_POSIX_Message_queue_Receive_support+0x45> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c82f: e8 d4 34 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c834: e9 9b 00 00 00 jmp 10c8d4 <_POSIX_Message_queue_Receive_support+0xe0> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10c839: 8b 49 10 mov 0x10(%ecx),%ecx <== NOT EXECUTED if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10c83c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c83f: 3b 41 68 cmp 0x68(%ecx),%eax <== NOT EXECUTED 10c842: 73 15 jae 10c859 <_POSIX_Message_queue_Receive_support+0x65> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c844: e8 bf 34 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10c849: e8 62 7b 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c84e: c7 00 7a 00 00 00 movl $0x7a,(%eax) <== NOT EXECUTED 10c854: e9 86 00 00 00 jmp 10c8df <_POSIX_Message_queue_Receive_support+0xeb> <== NOT EXECUTED length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10c859: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c85b: 84 db test %bl,%bl <== NOT EXECUTED 10c85d: 74 0b je 10c86a <_POSIX_Message_queue_Receive_support+0x76> <== NOT EXECUTED do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 10c85f: c1 ea 0e shr $0xe,%edx <== NOT EXECUTED 10c862: 83 f2 01 xor $0x1,%edx <== NOT EXECUTED 10c865: 88 d0 mov %dl,%al <== NOT EXECUTED 10c867: 83 e0 01 and $0x1,%eax <== NOT EXECUTED /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10c86a: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10c871: 52 push %edx <== NOT EXECUTED 10c872: 52 push %edx <== NOT EXECUTED 10c873: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10c876: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10c879: 50 push %eax <== NOT EXECUTED 10c87a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c87d: 50 push %eax <== NOT EXECUTED 10c87e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c881: 57 push %edi <== NOT EXECUTED 10c882: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10c885: 50 push %eax <== NOT EXECUTED 10c886: e8 41 1f 00 00 call 10e7cc <_CORE_message_queue_Seize> <== NOT EXECUTED &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10c88b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10c88e: e8 75 34 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED *msg_prio = 10c893: 8b 0d f8 62 12 00 mov 0x1262f8,%ecx <== NOT EXECUTED 10c899: 8b 41 24 mov 0x24(%ecx),%eax <== NOT EXECUTED 10c89c: c1 f8 1f sar $0x1f,%eax <== NOT EXECUTED 10c89f: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c8a1: 33 51 24 xor 0x24(%ecx),%edx <== NOT EXECUTED 10c8a4: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10c8a6: 29 06 sub %eax,(%esi) <== NOT EXECUTED _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10c8a8: 83 79 34 00 cmpl $0x0,0x34(%ecx) <== NOT EXECUTED 10c8ac: 75 05 jne 10c8b3 <_POSIX_Message_queue_Receive_support+0xbf> <== NOT EXECUTED return length_out; 10c8ae: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c8b1: eb 2f jmp 10c8e2 <_POSIX_Message_queue_Receive_support+0xee> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( 10c8b3: e8 f8 7a 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c8b8: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10c8ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c8bd: a1 f8 62 12 00 mov 0x1262f8,%eax <== NOT EXECUTED 10c8c2: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10c8c5: e8 fa 01 00 00 call 10cac4 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10c8ca: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10c8cc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c8cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8d2: eb 0e jmp 10c8e2 <_POSIX_Message_queue_Receive_support+0xee> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c8d4: e8 d7 7a 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c8d9: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10c8df: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10c8e2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c8e5: 5b pop %ebx <== NOT EXECUTED 10c8e6: 5e pop %esi <== NOT EXECUTED 10c8e7: 5f pop %edi <== NOT EXECUTED 10c8e8: c9 leave <== NOT EXECUTED 10c8e9: c3 ret <== NOT EXECUTED 0010c90c <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10c90c: 55 push %ebp <== NOT EXECUTED 10c90d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c90f: 56 push %esi <== NOT EXECUTED 10c910: 53 push %ebx <== NOT EXECUTED 10c911: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10c914: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c917: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10c91a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10c91d: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10c920: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10c923: 76 10 jbe 10c935 <_POSIX_Message_queue_Send_support+0x29> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c925: e8 86 7a 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c92a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c930: e9 9c 00 00 00 jmp 10c9d1 <_POSIX_Message_queue_Send_support+0xc5> <== NOT EXECUTED 10c935: 50 push %eax <== NOT EXECUTED 10c936: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10c939: 50 push %eax <== NOT EXECUTED 10c93a: 56 push %esi <== NOT EXECUTED 10c93b: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c940: e8 b7 2b 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c945: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c948: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10c94c: 75 78 jne 10c9c6 <_POSIX_Message_queue_Send_support+0xba> <== NOT EXECUTED case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10c94e: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10c951: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10c954: 75 07 jne 10c95d <_POSIX_Message_queue_Send_support+0x51> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c956: e8 ad 33 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c95b: eb 69 jmp 10c9c6 <_POSIX_Message_queue_Send_support+0xba> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10c95d: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10c960: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c962: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10c966: 74 0b je 10c973 <_POSIX_Message_queue_Send_support+0x67> <== NOT EXECUTED do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 10c968: c1 ea 0e shr $0xe,%edx <== NOT EXECUTED 10c96b: 83 f2 01 xor $0x1,%edx <== NOT EXECUTED 10c96e: 88 d0 mov %dl,%al <== NOT EXECUTED 10c970: 83 e0 01 and $0x1,%eax <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10c973: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10c976: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10c979: 50 push %eax <== NOT EXECUTED 10c97a: f7 db neg %ebx <== NOT EXECUTED 10c97c: 53 push %ebx <== NOT EXECUTED 10c97d: 6a 00 push $0x0 <== NOT EXECUTED 10c97f: 56 push %esi <== NOT EXECUTED 10c980: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c983: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c986: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10c989: 50 push %eax <== NOT EXECUTED 10c98a: e8 85 1f 00 00 call 10e914 <_CORE_message_queue_Submit> <== NOT EXECUTED 10c98f: 89 c6 mov %eax,%esi <== NOT EXECUTED _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10c991: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10c994: e8 6f 33 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 10c999: 83 fe 07 cmp $0x7,%esi <== NOT EXECUTED 10c99c: 75 08 jne 10c9a6 <_POSIX_Message_queue_Send_support+0x9a> <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; 10c99e: a1 f8 62 12 00 mov 0x1262f8,%eax <== NOT EXECUTED 10c9a3: 8b 70 34 mov 0x34(%eax),%esi <== NOT EXECUTED if ( !msg_status ) 10c9a6: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c9a8: 85 f6 test %esi,%esi <== NOT EXECUTED 10c9aa: 74 28 je 10c9d4 <_POSIX_Message_queue_Send_support+0xc8> <== NOT EXECUTED return msg_status; rtems_set_errno_and_return_minus_one( 10c9ac: e8 ff 79 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c9b1: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10c9b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9b6: 56 push %esi <== NOT EXECUTED 10c9b7: e8 08 01 00 00 call 10cac4 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10c9bc: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10c9be: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c9c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9c4: eb 0e jmp 10c9d4 <_POSIX_Message_queue_Send_support+0xc8> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c9c6: e8 e5 79 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c9cb: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10c9d1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10c9d4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c9d7: 5b pop %ebx <== NOT EXECUTED 10c9d8: 5e pop %esi <== NOT EXECUTED 10c9d9: c9 leave <== NOT EXECUTED 10c9da: c3 ret <== NOT EXECUTED 0010cac4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>: int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { 10cac4: 55 push %ebp <== NOT EXECUTED 10cac5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cac7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10caca: 8b 04 85 14 ed 11 00 mov 0x11ed14(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_message_queue_status > CORE_MESSAGE_QUEUE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Message_queue_Return_codes[the_message_queue_status]; } 10cad1: c9 leave <== NOT EXECUTED 10cad2: c3 ret <== NOT EXECUTED 0010a7e1 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10a7e1: 55 push %ebp <== NOT EXECUTED 10a7e2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7e4: 56 push %esi <== NOT EXECUTED 10a7e5: 53 push %ebx <== NOT EXECUTED 10a7e6: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a7e9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10a7ec: 85 db test %ebx,%ebx <== NOT EXECUTED 10a7ee: 74 16 je 10a806 <_POSIX_Mutex_Get+0x25> <== NOT EXECUTED 10a7f0: 83 3b ff cmpl $0xffffffff,(%ebx) <== NOT EXECUTED 10a7f3: 75 1b jne 10a810 <_POSIX_Mutex_Get+0x2f> <== NOT EXECUTED 10a7f5: 51 push %ecx <== NOT EXECUTED 10a7f6: 51 push %ecx <== NOT EXECUTED 10a7f7: 6a 00 push $0x0 <== NOT EXECUTED 10a7f9: 53 push %ebx <== NOT EXECUTED 10a7fa: e8 6d 00 00 00 call 10a86c <== NOT EXECUTED 10a7ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a802: 85 c0 test %eax,%eax <== NOT EXECUTED 10a804: 74 0a je 10a810 <_POSIX_Mutex_Get+0x2f> <== NOT EXECUTED 10a806: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a80c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a80e: eb 11 jmp 10a821 <_POSIX_Mutex_Get+0x40> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10a810: 52 push %edx <== NOT EXECUTED 10a811: 56 push %esi <== NOT EXECUTED 10a812: ff 33 pushl (%ebx) <== NOT EXECUTED 10a814: 68 f8 2d 12 00 push $0x122df8 <== NOT EXECUTED 10a819: e8 1e 29 00 00 call 10d13c <_Objects_Get> <== NOT EXECUTED 10a81e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Mutex_Information, *id, location ); } 10a821: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a824: 5b pop %ebx <== NOT EXECUTED 10a825: 5e pop %esi <== NOT EXECUTED 10a826: c9 leave <== NOT EXECUTED 10a827: c3 ret <== NOT EXECUTED 0010a798 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10a798: 55 push %ebp <== NOT EXECUTED 10a799: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a79b: 56 push %esi <== NOT EXECUTED 10a79c: 53 push %ebx <== NOT EXECUTED 10a79d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a7a0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10a7a3: 85 db test %ebx,%ebx <== NOT EXECUTED 10a7a5: 74 16 je 10a7bd <_POSIX_Mutex_Get_interrupt_disable+0x25> <== NOT EXECUTED 10a7a7: 83 3b ff cmpl $0xffffffff,(%ebx) <== NOT EXECUTED 10a7aa: 75 1b jne 10a7c7 <_POSIX_Mutex_Get_interrupt_disable+0x2f> <== NOT EXECUTED 10a7ac: 50 push %eax <== NOT EXECUTED 10a7ad: 50 push %eax <== NOT EXECUTED 10a7ae: 6a 00 push $0x0 <== NOT EXECUTED 10a7b0: 53 push %ebx <== NOT EXECUTED 10a7b1: e8 b6 00 00 00 call 10a86c <== NOT EXECUTED 10a7b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7b9: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7bb: 74 0a je 10a7c7 <_POSIX_Mutex_Get_interrupt_disable+0x2f> <== NOT EXECUTED 10a7bd: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a7c3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a7c5: eb 13 jmp 10a7da <_POSIX_Mutex_Get_interrupt_disable+0x42> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10a7c7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a7ca: 56 push %esi <== NOT EXECUTED 10a7cb: ff 33 pushl (%ebx) <== NOT EXECUTED 10a7cd: 68 f8 2d 12 00 push $0x122df8 <== NOT EXECUTED 10a7d2: e8 19 29 00 00 call 10d0f0 <_Objects_Get_isr_disable> <== NOT EXECUTED 10a7d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level ); } 10a7da: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a7dd: 5b pop %ebx <== NOT EXECUTED 10a7de: 5e pop %esi <== NOT EXECUTED 10a7df: c9 leave <== NOT EXECUTED 10a7e0: c3 ret <== NOT EXECUTED 0010a990 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, bool blocking, Watchdog_Interval timeout ) { 10a990: 55 push %ebp <== NOT EXECUTED 10a991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a993: 53 push %ebx <== NOT EXECUTED 10a994: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a997: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); 10a99a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a99d: 50 push %eax <== NOT EXECUTED 10a99e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a9a1: 50 push %eax <== NOT EXECUTED 10a9a2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a9a5: e8 ee fd ff ff call 10a798 <_POSIX_Mutex_Get_interrupt_disable> <== NOT EXECUTED 10a9aa: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a9ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9af: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10a9b4: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a9b8: 75 2c jne 10a9e6 <_POSIX_Mutex_Lock_support+0x56> <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_mutex_Seize( 10a9ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9bd: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10a9c0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a9c3: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10a9c6: 50 push %eax <== NOT EXECUTED 10a9c7: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10a9ca: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10a9cd: 50 push %eax <== NOT EXECUTED 10a9ce: e8 75 1d 00 00 call 10c748 <_CORE_mutex_Seize> <== NOT EXECUTED the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10a9d3: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10a9d6: a1 08 2b 12 00 mov 0x122b08,%eax <== NOT EXECUTED 10a9db: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a9de: e8 c5 00 00 00 call 10aaa8 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10a9e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a9e6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a9e9: c9 leave <== NOT EXECUTED 10a9ea: c3 ret <== NOT EXECUTED 0010d37c <_POSIX_Mutex_Manager_initialization>: */ void _POSIX_Mutex_Manager_initialization( uint32_t maximum_mutexes ) { 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: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d387: 6a 01 push $0x1 <== NOT EXECUTED 10d389: 6a 78 push $0x78 <== NOT EXECUTED 10d38b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d38e: 6a 06 push $0x6 <== NOT EXECUTED 10d390: 6a 03 push $0x3 <== NOT EXECUTED 10d392: 68 28 da 11 00 push $0x11da28 <== NOT EXECUTED 10d397: e8 5c d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d39c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d39f: c9 leave <== NOT EXECUTED 10d3a0: c3 ret <== NOT EXECUTED 0010aaa8 <_POSIX_Mutex_Translate_core_mutex_return_code>: int _POSIX_Mutex_Translate_core_mutex_return_code( CORE_mutex_Status the_mutex_status ) { 10aaa8: 55 push %ebp <== NOT EXECUTED 10aaa9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aaab: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aaae: 8b 04 85 44 c3 11 00 mov 0x11c344(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_mutex_status > CORE_MUTEX_STATUS_LAST ) return EINVAL; #endif return _POSIX_Mutex_Return_codes[the_mutex_status]; } 10aab5: c9 leave <== NOT EXECUTED 10aab6: c3 ret <== NOT EXECUTED 0010d3cc <_POSIX_RWLock_Manager_initialization>: */ void _POSIX_RWLock_Manager_initialization( uint32_t maximum_rwlocks ) { 10d3cc: 55 push %ebp <== NOT EXECUTED 10d3cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d3d2: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d3d7: 6a 01 push $0x1 <== NOT EXECUTED 10d3d9: 6a 5c push $0x5c <== NOT EXECUTED 10d3db: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3de: 6a 0b push $0xb <== NOT EXECUTED 10d3e0: 6a 03 push $0x3 <== NOT EXECUTED 10d3e2: 68 a8 d8 11 00 push $0x11d8a8 <== NOT EXECUTED 10d3e7: e8 0c d3 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d3ec: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d3ef: c9 leave <== NOT EXECUTED 10d3f0: c3 ret <== NOT EXECUTED 00109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code>: int _POSIX_RWLock_Translate_core_RWLock_return_code( CORE_RWLock_Status the_rwlock_status ) { 109a08: 55 push %ebp <== NOT EXECUTED 109a09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a0b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109a0e: 8b 04 85 e0 95 11 00 mov 0x1195e0(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_rwlock_status > CORE_RWLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_RWLock_Return_codes[the_rwlock_status]; } 109a15: c9 leave <== NOT EXECUTED 109a16: c3 ret <== NOT EXECUTED 00110a70 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 110a70: 55 push %ebp <== NOT EXECUTED 110a71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110a73: 57 push %edi <== NOT EXECUTED 110a74: 56 push %esi <== NOT EXECUTED 110a75: 53 push %ebx <== NOT EXECUTED 110a76: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110a79: 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 110a7c: a1 f0 33 12 00 mov 0x1233f0,%eax <== NOT EXECUTED 110a81: 40 inc %eax <== NOT EXECUTED 110a82: a3 f0 33 12 00 mov %eax,0x1233f0 <== NOT EXECUTED char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 110a87: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 110a8b: 74 12 je 110a9f <_POSIX_Semaphore_Create_support+0x2f> <== NOT EXECUTED _Thread_Enable_dispatch(); 110a8d: e8 2a d2 ff ff call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 110a92: e8 5d 1b 00 00 call 1125f4 <__errno> <== NOT EXECUTED 110a97: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 110a9d: eb 28 jmp 110ac7 <_POSIX_Semaphore_Create_support+0x57> <== NOT EXECUTED } if ( name ) { 110a9f: 85 f6 test %esi,%esi <== NOT EXECUTED 110aa1: 74 2c je 110acf <_POSIX_Semaphore_Create_support+0x5f> <== NOT EXECUTED if( strlen(name) > PATH_MAX ) { 110aa3: 31 c0 xor %eax,%eax <== NOT EXECUTED 110aa5: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 110aa8: 89 f7 mov %esi,%edi <== NOT EXECUTED 110aaa: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 110aac: f7 d1 not %ecx <== NOT EXECUTED 110aae: 49 dec %ecx <== NOT EXECUTED 110aaf: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 110ab5: 76 18 jbe 110acf <_POSIX_Semaphore_Create_support+0x5f> <== NOT EXECUTED _Thread_Enable_dispatch(); 110ab7: e8 00 d2 ff ff call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 110abc: e8 33 1b 00 00 call 1125f4 <__errno> <== NOT EXECUTED 110ac1: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 110ac7: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 110aca: e9 90 00 00 00 jmp 110b5f <_POSIX_Semaphore_Create_support+0xef> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 110acf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ad2: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 110ad7: e8 dc c5 ff ff call 10d0b8 <_Objects_Allocate> <== NOT EXECUTED 110adc: 89 c3 mov %eax,%ebx <== NOT EXECUTED } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 110ade: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110ae1: 85 c0 test %eax,%eax <== NOT EXECUTED 110ae3: 75 12 jne 110af7 <_POSIX_Semaphore_Create_support+0x87> <== NOT EXECUTED _Thread_Enable_dispatch(); 110ae5: e8 d2 d1 ff ff call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 110aea: e8 05 1b 00 00 call 1125f4 <__errno> <== NOT EXECUTED 110aef: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 110af5: eb d0 jmp 110ac7 <_POSIX_Semaphore_Create_support+0x57> <== NOT EXECUTED } the_semaphore->process_shared = pshared; 110af7: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED if ( name ) { 110afe: 85 f6 test %esi,%esi <== NOT EXECUTED 110b00: 74 11 je 110b13 <_POSIX_Semaphore_Create_support+0xa3> <== NOT EXECUTED the_semaphore->named = TRUE; 110b02: c6 40 14 01 movb $0x1,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 1; 110b06: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = TRUE; 110b0d: c6 40 15 01 movb $0x1,0x15(%eax) <== NOT EXECUTED 110b11: eb 0f jmp 110b22 <_POSIX_Semaphore_Create_support+0xb2> <== NOT EXECUTED } else { the_semaphore->named = FALSE; 110b13: c6 40 14 00 movb $0x0,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 0; 110b17: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = FALSE; 110b1e: c6 40 15 00 movb $0x0,0x15(%eax) <== NOT EXECUTED * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 110b22: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 110b29: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx) <== NOT EXECUTED _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 110b30: 50 push %eax <== NOT EXECUTED 110b31: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 110b34: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED 110b37: 50 push %eax <== NOT EXECUTED 110b38: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 110b3b: 50 push %eax <== NOT EXECUTED 110b3c: e8 b3 c1 ff ff call 10ccf4 <_CORE_semaphore_Initialize> <== NOT EXECUTED 110b41: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 110b45: a1 fc 36 12 00 mov 0x1236fc,%eax <== NOT EXECUTED 110b4a: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 110b4d: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 110b50: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 110b53: 89 18 mov %ebx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 110b55: e8 62 d1 ff ff call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 110b5a: 31 c0 xor %eax,%eax <== NOT EXECUTED 110b5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 110b5f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110b62: 5b pop %ebx <== NOT EXECUTED 110b63: 5e pop %esi <== NOT EXECUTED 110b64: 5f pop %edi <== NOT EXECUTED 110b65: c9 leave <== NOT EXECUTED 110b66: c3 ret <== NOT EXECUTED 00110b68 <_POSIX_Semaphore_Delete>: */ void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore ) { 110b68: 55 push %ebp <== NOT EXECUTED 110b69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110b6b: 53 push %ebx <== NOT EXECUTED 110b6c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110b6f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_semaphore->linked && !the_semaphore->open_count ) { 110b72: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 110b76: 75 33 jne 110bab <_POSIX_Semaphore_Delete+0x43> <== NOT EXECUTED 110b78: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 110b7c: 75 2d jne 110bab <_POSIX_Semaphore_Delete+0x43> <== NOT EXECUTED _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object ); 110b7e: 51 push %ecx <== NOT EXECUTED 110b7f: 51 push %ecx <== NOT EXECUTED 110b80: 53 push %ebx <== NOT EXECUTED 110b81: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 110b86: e8 a1 c5 ff ff call 10d12c <_Objects_Close> <== NOT EXECUTED _CORE_semaphore_Flush( 110b8b: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110b8e: 6a ff push $0xffffffff <== NOT EXECUTED 110b90: 6a 00 push $0x0 <== NOT EXECUTED 110b92: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 110b95: 50 push %eax <== NOT EXECUTED 110b96: e8 4d c1 ff ff call 10cce8 <_CORE_semaphore_Flush> <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 110b9b: 58 pop %eax <== NOT EXECUTED 110b9c: 5a pop %edx <== NOT EXECUTED 110b9d: 53 push %ebx <== NOT EXECUTED 110b9e: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 110ba3: e8 20 c8 ff ff call 10d3c8 <_Objects_Free> <== NOT EXECUTED 110ba8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED -1 ); _POSIX_Semaphore_Free( the_semaphore ); } } 110bab: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110bae: c9 leave <== NOT EXECUTED 110baf: c3 ret <== NOT EXECUTED 0010d87c <_POSIX_Semaphore_Manager_initialization>: */ void _POSIX_Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10d87c: 55 push %ebp <== NOT EXECUTED 10d87d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d87f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d882: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d887: 6a 01 push $0x1 <== NOT EXECUTED 10d889: 6a 68 push $0x68 <== NOT EXECUTED 10d88b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d88e: 6a 07 push $0x7 <== NOT EXECUTED 10d890: 6a 03 push $0x3 <== NOT EXECUTED 10d892: 68 68 d9 11 00 push $0x11d968 <== NOT EXECUTED 10d897: e8 5c ce ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d89c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d89f: c9 leave <== NOT EXECUTED 10d8a0: c3 ret <== NOT EXECUTED 00110bb0 <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 110bb0: 55 push %ebp <== NOT EXECUTED 110bb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110bb3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110bb6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 110bb9: 85 c0 test %eax,%eax <== NOT EXECUTED 110bbb: 74 23 je 110be0 <_POSIX_Semaphore_Name_to_id+0x30> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 110bbd: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 110bc0: 74 1e je 110be0 <_POSIX_Semaphore_Name_to_id+0x30> <== NOT EXECUTED return EINVAL; status = _Objects_Name_to_id_string( 110bc2: 52 push %edx <== NOT EXECUTED 110bc3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 110bc6: 50 push %eax <== NOT EXECUTED 110bc7: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 110bcc: e8 bb 09 00 00 call 11158c <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Semaphore_Information, name, (Objects_Id*)id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 110bd1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110bd4: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110bd7: 19 c0 sbb %eax,%eax <== NOT EXECUTED 110bd9: f7 d0 not %eax <== NOT EXECUTED 110bdb: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 110bde: eb 05 jmp 110be5 <_POSIX_Semaphore_Name_to_id+0x35> <== NOT EXECUTED 110be0: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 110be5: c9 leave <== NOT EXECUTED 110be6: c3 ret <== NOT EXECUTED 00112190 <_POSIX_Semaphore_Translate_core_semaphore_return_code>: int _POSIX_Semaphore_Translate_core_semaphore_return_code( CORE_semaphore_Status the_semaphore_status ) { 112190: 55 push %ebp <== NOT EXECUTED 112191: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112193: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112196: 8b 04 85 7c cc 11 00 mov 0x11cc7c(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_semaphore_status > CORE_SEMAPHORE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Semaphore_Return_codes[the_semaphore_status]; } 11219d: c9 leave <== NOT EXECUTED 11219e: c3 ret <== NOT EXECUTED 00110c10 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 110c10: 55 push %ebp <== NOT EXECUTED 110c11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110c13: 53 push %ebx <== NOT EXECUTED 110c14: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 110c17: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 110c1a: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110c1d: 50 push %eax <== NOT EXECUTED 110c1e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110c21: ff 30 pushl (%eax) <== NOT EXECUTED 110c23: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 110c28: e8 cf c8 ff ff call 10d4fc <_Objects_Get> <== NOT EXECUTED 110c2d: 89 c2 mov %eax,%edx <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 110c2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110c32: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110c36: 75 49 jne 110c81 <_POSIX_Semaphore_Wait_support+0x71> <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_semaphore_Seize( 110c38: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 110c3b: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 110c3e: 50 push %eax <== NOT EXECUTED 110c3f: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 110c42: 8d 42 1c lea 0x1c(%edx),%eax <== NOT EXECUTED 110c45: 50 push %eax <== NOT EXECUTED 110c46: e8 75 06 00 00 call 1112c0 <_CORE_semaphore_Seize> <== NOT EXECUTED &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 110c4b: e8 6c d0 ff ff call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !_Thread_Executing->Wait.return_code ) 110c50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110c53: 31 d2 xor %edx,%edx <== NOT EXECUTED 110c55: a1 b0 34 12 00 mov 0x1234b0,%eax <== NOT EXECUTED 110c5a: 83 78 34 00 cmpl $0x0,0x34(%eax) <== NOT EXECUTED 110c5e: 74 2f je 110c8f <_POSIX_Semaphore_Wait_support+0x7f> <== NOT EXECUTED return 0; rtems_set_errno_and_return_minus_one( 110c60: e8 8f 19 00 00 call 1125f4 <__errno> <== NOT EXECUTED 110c65: 89 c3 mov %eax,%ebx <== NOT EXECUTED 110c67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110c6a: a1 b0 34 12 00 mov 0x1234b0,%eax <== NOT EXECUTED 110c6f: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 110c72: e8 19 15 00 00 call 112190 <_POSIX_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 110c77: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 110c79: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 110c7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110c7f: eb 0e jmp 110c8f <_POSIX_Semaphore_Wait_support+0x7f> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 110c81: e8 6e 19 00 00 call 1125f4 <__errno> <== NOT EXECUTED 110c86: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 110c8c: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED } 110c8f: 89 d0 mov %edx,%eax <== NOT EXECUTED 110c91: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110c94: c9 leave <== NOT EXECUTED 110c95: c3 ret <== NOT EXECUTED 0010d53c <_POSIX_Spinlock_Manager_initialization>: */ void _POSIX_Spinlock_Manager_initialization( uint32_t maximum_spinlocks ) { 10d53c: 55 push %ebp <== NOT EXECUTED 10d53d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d53f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d542: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d547: 6a 01 push $0x1 <== NOT EXECUTED 10d549: 6a 20 push $0x20 <== NOT EXECUTED 10d54b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d54e: 6a 0b push $0xb <== NOT EXECUTED 10d550: 6a 03 push $0x3 <== NOT EXECUTED 10d552: 68 28 d9 11 00 push $0x11d928 <== NOT EXECUTED 10d557: e8 9c d1 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d55c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d55f: c9 leave <== NOT EXECUTED 10d560: c3 ret <== NOT EXECUTED 001090ac <_POSIX_Spinlock_Translate_core_spinlock_return_code>: int _POSIX_Spinlock_Translate_core_spinlock_return_code( CORE_spinlock_Status the_spinlock_status ) { 1090ac: 55 push %ebp <== NOT EXECUTED 1090ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090af: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1090b2: 8b 04 85 10 81 11 00 mov 0x118110(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_spinlock_status > CORE_SPINLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_Spinlock_Return_codes[the_spinlock_status]; } 1090b9: c9 leave <== NOT EXECUTED 1090ba: c3 ret <== NOT EXECUTED 0010ebe4 <_POSIX_Thread_Exit>: void _POSIX_Thread_Exit( Thread_Control *the_thread, void *value_ptr ) { 10ebe4: 55 push %ebp <== NOT EXECUTED 10ebe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ebe7: 57 push %edi <== NOT EXECUTED 10ebe8: 56 push %esi <== NOT EXECUTED 10ebe9: 53 push %ebx <== NOT EXECUTED 10ebea: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10ebed: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ebf0: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *the_information; the_information = _Objects_Get_information_id( the_thread->Object.id ); 10ebf3: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10ebf6: e8 e5 b9 ff ff call 10a5e0 <_Objects_Get_information_id> <== NOT EXECUTED 10ebfb: 89 c6 mov %eax,%esi <== NOT EXECUTED * are ready to be switched out. Otherwise, an ISR could * occur and preempt us out while we still hold the * allocator mutex. */ _RTEMS_Lock_allocator(); 10ebfd: 58 pop %eax <== NOT EXECUTED 10ebfe: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10ec04: e8 43 ae ff ff call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ec09: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ec0e: 40 inc %eax <== NOT EXECUTED 10ec0f: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.return_argument = value_ptr; 10ec14: 89 7b 28 mov %edi,0x28(%ebx) <== NOT EXECUTED _Thread_Close( the_information, the_thread ); 10ec17: 5f pop %edi <== NOT EXECUTED 10ec18: 58 pop %eax <== NOT EXECUTED 10ec19: 53 push %ebx <== NOT EXECUTED 10ec1a: 56 push %esi <== NOT EXECUTED 10ec1b: e8 48 bf ff ff call 10ab68 <_Thread_Close> <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10ec20: 5a pop %edx <== NOT EXECUTED 10ec21: 59 pop %ecx <== NOT EXECUTED 10ec22: 53 push %ebx <== NOT EXECUTED 10ec23: 68 e8 d8 11 00 push $0x11d8e8 <== NOT EXECUTED 10ec28: e8 3f b9 ff ff call 10a56c <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10ec2d: 58 pop %eax <== NOT EXECUTED 10ec2e: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10ec34: e8 5b ae ff ff call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ec39: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ec3c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ec3f: 5b pop %ebx <== NOT EXECUTED 10ec40: 5e pop %esi <== NOT EXECUTED 10ec41: 5f pop %edi <== NOT EXECUTED 10ec42: c9 leave <== NOT EXECUTED _Thread_Close( the_information, the_thread ); _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); _Thread_Enable_dispatch(); 10ec43: e9 18 c2 ff ff jmp 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010d65d <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10d65d: 55 push %ebp <== NOT EXECUTED 10d65e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d660: 57 push %edi <== NOT EXECUTED 10d661: 56 push %esi <== NOT EXECUTED 10d662: 53 push %ebx <== NOT EXECUTED 10d663: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 10d666: 68 e4 00 00 00 push $0xe4 <== NOT EXECUTED 10d66b: e8 8d e7 ff ff call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10d670: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !api ) 10d672: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d675: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d677: 85 db test %ebx,%ebx <== NOT EXECUTED 10d679: 0f 84 05 01 00 00 je 10d784 <_POSIX_Threads_Create_extension+0x127> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 10d67f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d682: 89 98 f8 00 00 00 mov %ebx,0xf8(%eax) <== NOT EXECUTED /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 10d688: be 24 78 11 00 mov $0x117824,%esi <== NOT EXECUTED 10d68d: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10d692: 89 df mov %ebx,%edi <== NOT EXECUTED 10d694: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 10d696: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 10d69d: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 10d6a4: be 3c 78 11 00 mov $0x11783c,%esi <== NOT EXECUTED 10d6a9: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10d6af: b1 06 mov $0x6,%cl <== NOT EXECUTED 10d6b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->schedparam.sched_priority = 10d6b3: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10d6b8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d6bb: 2b 42 14 sub 0x14(%edx),%eax <== NOT EXECUTED 10d6be: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 10d6c4: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) <== NOT EXECUTED 10d6cb: 00 00 00 <== NOT EXECUTED api->cancelability_state = PTHREAD_CANCEL_ENABLE; 10d6ce: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx) <== NOT EXECUTED 10d6d5: 00 00 00 <== NOT EXECUTED api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 10d6d8: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 10d6df: 00 00 00 <== NOT EXECUTED 10d6e2: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax <== NOT EXECUTED 10d6e8: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10d6ee: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) <== NOT EXECUTED 10d6f5: 00 00 00 <== NOT EXECUTED 10d6f8: 8d 83 d8 00 00 00 lea 0xd8(%ebx),%eax <== NOT EXECUTED 10d6fe: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 10d704: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10d70b: 00 00 00 <== NOT EXECUTED if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10d70e: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED 10d711: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d713: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10d716: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10d719: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10d71c: 75 1f jne 10d73d <_POSIX_Threads_Create_extension+0xe0> <== NOT EXECUTED 10d71e: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10d721: 4a dec %edx <== NOT EXECUTED 10d722: 75 19 jne 10d73d <_POSIX_Threads_Create_extension+0xe0> <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 10d724: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED 10d729: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10d72f: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 10d735: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED 10d73b: eb 0a jmp 10d747 <_POSIX_Threads_Create_extension+0xea> <== NOT EXECUTED } else { api->signals_blocked = 0xffffffff; 10d73d: c7 83 c4 00 00 00 ff movl $0xffffffff,0xc4(%ebx) <== NOT EXECUTED 10d744: ff ff ff <== NOT EXECUTED } _Thread_queue_Initialize( 10d747: 6a 00 push $0x0 <== NOT EXECUTED 10d749: 68 00 10 00 00 push $0x1000 <== NOT EXECUTED 10d74e: 6a 00 push $0x0 <== NOT EXECUTED 10d750: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10d753: 50 push %eax <== NOT EXECUTED 10d754: e8 8b dd ff ff call 10b4e4 <_Thread_queue_Initialize> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 10d759: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d75c: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10d75f: c7 83 a4 00 00 00 00 movl $0x0,0xa4(%ebx) <== NOT EXECUTED 10d766: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d769: c7 83 b8 00 00 00 ca movl $0x10d7ca,0xb8(%ebx) <== NOT EXECUTED 10d770: d7 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10d773: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED * the heap 10d779: 89 93 c0 00 00 00 mov %edx,0xc0(%ebx) <== NOT EXECUTED 10d77f: b0 01 mov $0x1,%al <== NOT EXECUTED 10d781: 83 c4 10 add $0x10,%esp <== NOT EXECUTED created->Object.id, created ); return true; } 10d784: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d787: 5b pop %ebx <== NOT EXECUTED 10d788: 5e pop %esi <== NOT EXECUTED 10d789: 5f pop %edi <== NOT EXECUTED 10d78a: c9 leave <== NOT EXECUTED 10d78b: c3 ret <== NOT EXECUTED 0010d5e6 <_POSIX_Threads_Delete_extension>: User_extensions_routine _POSIX_Threads_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10d5e6: 55 push %ebp <== NOT EXECUTED 10d5e7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5e9: 57 push %edi <== NOT EXECUTED 10d5ea: 56 push %esi <== NOT EXECUTED 10d5eb: 53 push %ebx <== NOT EXECUTED 10d5ec: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10d5ef: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 10d5f2: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi <== NOT EXECUTED /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 10d5f8: 53 push %ebx <== NOT EXECUTED 10d5f9: e8 6e 13 00 00 call 10e96c <_POSIX_Threads_cancel_run> <== NOT EXECUTED /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 10d5fe: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d601: e8 c2 13 00 00 call 10e9c8 <_POSIX_Keys_Run_destructors> <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 10d606: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10d609: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10d60c: 8d 7e 3c lea 0x3c(%esi),%edi <== NOT EXECUTED 10d60f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d612: eb 08 jmp 10d61c <_POSIX_Threads_Delete_extension+0x36> <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; 10d614: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10d617: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10d61a: 89 10 mov %edx,(%eax) <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10d61c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d61f: 57 push %edi <== NOT EXECUTED 10d620: e8 73 db ff ff call 10b198 <_Thread_queue_Dequeue> <== NOT EXECUTED 10d625: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d628: 85 c0 test %eax,%eax <== NOT EXECUTED 10d62a: 75 e8 jne 10d614 <_POSIX_Threads_Delete_extension+0x2e> <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 10d62c: 83 7e 7c 03 cmpl $0x3,0x7c(%esi) <== NOT EXECUTED 10d630: 75 12 jne 10d644 <_POSIX_Threads_Delete_extension+0x5e> <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); 10d632: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d635: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax <== NOT EXECUTED 10d63b: 50 push %eax <== NOT EXECUTED 10d63c: e8 d3 e6 ff ff call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED 10d641: 83 c4 10 add $0x10,%esp <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 10d644: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx) <== NOT EXECUTED 10d64b: 00 00 00 <== NOT EXECUTED (void) _Workspace_Free( api ); 10d64e: 89 75 08 mov %esi,0x8(%ebp) <== NOT EXECUTED } 10d651: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d654: 5b pop %ebx <== NOT EXECUTED 10d655: 5e pop %esi <== NOT EXECUTED 10d656: 5f pop %edi <== NOT EXECUTED 10d657: c9 leave <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; (void) _Workspace_Free( api ); 10d658: e9 8b e7 ff ff jmp 10bde8 <_Workspace_Free> <== NOT EXECUTED 0010d5c6 <_POSIX_Threads_Exitted_extension>: */ User_extensions_routine _POSIX_Threads_Exitted_extension( Thread_Control *executing ) { 10d5c6: 55 push %ebp <== NOT EXECUTED 10d5c7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5c9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) 10d5cc: 0f b6 42 0b movzbl 0xb(%edx),%eax <== NOT EXECUTED 10d5d0: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10d5d3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10d5d6: 75 0c jne 10d5e4 <_POSIX_Threads_Exitted_extension+0x1e> <== NOT EXECUTED pthread_exit( executing->Wait.return_argument ); 10d5d8: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10d5db: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10d5de: c9 leave <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) pthread_exit( executing->Wait.return_argument ); 10d5df: e9 64 16 00 00 jmp 10ec48 <== NOT EXECUTED } 10d5e4: c9 leave <== NOT EXECUTED 10d5e5: c3 ret <== NOT EXECUTED 0010d564 <_POSIX_Threads_Initialize_user_threads>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads( void ) { 10d564: 55 push %ebp <== NOT EXECUTED 10d565: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _POSIX_Threads_Initialize_user_threads_p ) 10d567: 8b 0d f4 ba 11 00 mov 0x11baf4,%ecx <== NOT EXECUTED 10d56d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d56f: 74 03 je 10d574 <_POSIX_Threads_Initialize_user_threads+0x10> <== NOT EXECUTED (*_POSIX_Threads_Initialize_user_threads_p)(); } 10d571: c9 leave <== NOT EXECUTED */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 10d572: ff e1 jmp *%ecx <== NOT EXECUTED } 10d574: c9 leave <== NOT EXECUTED 10d575: c3 ret <== NOT EXECUTED 00109d20 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 109d20: 55 push %ebp <== NOT EXECUTED 109d21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d23: 57 push %edi <== NOT EXECUTED 109d24: 56 push %esi <== NOT EXECUTED 109d25: 53 push %ebx <== NOT EXECUTED 109d26: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 109d29: 8b 35 00 14 12 00 mov 0x121400,%esi <== NOT EXECUTED maximum = _POSIX_Threads_Number_of_initialization_threads; 109d2f: a1 b8 14 12 00 mov 0x1214b8,%eax <== NOT EXECUTED 109d34: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED if ( !user_threads || maximum == 0 ) 109d37: 85 f6 test %esi,%esi <== NOT EXECUTED 109d39: 74 51 je 109d8c <_POSIX_Threads_Initialize_user_threads_body+0x6c> <== NOT EXECUTED 109d3b: 85 c0 test %eax,%eax <== NOT EXECUTED 109d3d: 74 4d je 109d8c <_POSIX_Threads_Initialize_user_threads_body+0x6c> <== NOT EXECUTED return; 109d3f: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 109d41: 8d 7d b8 lea -0x48(%ebp),%edi <== NOT EXECUTED 109d44: eb 41 jmp 109d87 <_POSIX_Threads_Initialize_user_threads_body+0x67> <== NOT EXECUTED 109d46: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d49: 57 push %edi <== NOT EXECUTED 109d4a: e8 89 54 00 00 call 10f1d8 <== NOT EXECUTED (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 109d4f: 58 pop %eax <== NOT EXECUTED 109d50: 5a pop %edx <== NOT EXECUTED 109d51: 6a 02 push $0x2 <== NOT EXECUTED 109d53: 57 push %edi <== NOT EXECUTED 109d54: e8 a7 54 00 00 call 10f200 <== NOT EXECUTED (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 109d59: 59 pop %ecx <== NOT EXECUTED 109d5a: 58 pop %eax <== NOT EXECUTED 109d5b: ff 74 de 04 pushl 0x4(%esi,%ebx,8) <== NOT EXECUTED 109d5f: 57 push %edi <== NOT EXECUTED 109d60: e8 cf 54 00 00 call 10f234 <== NOT EXECUTED status = pthread_create( 109d65: 6a 00 push $0x0 <== NOT EXECUTED 109d67: ff 34 de pushl (%esi,%ebx,8) <== NOT EXECUTED 109d6a: 57 push %edi <== NOT EXECUTED 109d6b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109d6e: 50 push %eax <== NOT EXECUTED 109d6f: e8 84 fc ff ff call 1099f8 <== NOT EXECUTED &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 109d74: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109d77: 85 c0 test %eax,%eax <== NOT EXECUTED 109d79: 74 0b je 109d86 <_POSIX_Threads_Initialize_user_threads_body+0x66> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); 109d7b: 52 push %edx <== NOT EXECUTED 109d7c: 50 push %eax <== NOT EXECUTED 109d7d: 6a 01 push $0x1 <== NOT EXECUTED 109d7f: 6a 02 push $0x2 <== NOT EXECUTED 109d81: e8 36 1e 00 00 call 10bbbc <_Internal_error_Occurred> <== NOT EXECUTED * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 109d86: 43 inc %ebx <== NOT EXECUTED 109d87: 3b 5d b0 cmp -0x50(%ebp),%ebx <== NOT EXECUTED 109d8a: 72 ba jb 109d46 <_POSIX_Threads_Initialize_user_threads_body+0x26> <== NOT EXECUTED NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); } } 109d8c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109d8f: 5b pop %ebx <== NOT EXECUTED 109d90: 5e pop %esi <== NOT EXECUTED 109d91: 5f pop %edi <== NOT EXECUTED 109d92: c9 leave <== NOT EXECUTED 109d93: c3 ret <== NOT EXECUTED 0010d576 <_POSIX_Threads_Manager_initialization>: uint32_t maximum_pthreads, uint32_t number_of_initialization_threads, posix_initialization_threads_table *user_threads ) { 10d576: 55 push %ebp <== NOT EXECUTED 10d577: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d579: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _POSIX_Threads_Number_of_initialization_threads = 10d57c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d57f: a3 60 db 11 00 mov %eax,0x11db60 <== NOT EXECUTED number_of_initialization_threads; _POSIX_Threads_User_initialization_threads = user_threads; 10d584: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10d587: a3 a8 da 11 00 mov %eax,0x11daa8 <== NOT EXECUTED #if 0 if ( user_threads == NULL || number_of_initialization_threads == 0 ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, EINVAL ); #endif _Objects_Initialize_information( 10d58c: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d591: 6a 01 push $0x1 <== NOT EXECUTED 10d593: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10d598: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d59b: 6a 01 push $0x1 <== NOT EXECUTED 10d59d: 6a 03 push $0x3 <== NOT EXECUTED 10d59f: 68 e8 d8 11 00 push $0x11d8e8 <== NOT EXECUTED 10d5a4: e8 4f d1 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); 10d5a9: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10d5ac: 68 64 b5 11 00 push $0x11b564 <== NOT EXECUTED 10d5b1: e8 1e 0f 00 00 call 10e4d4 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10d5b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5b9: c7 45 08 50 b5 11 00 movl $0x11b550,0x8(%ebp) <== NOT EXECUTED /* * If we supported MP, then here we would ... * Register the MP Process Packet routine. */ } 10d5c0: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10d5c1: e9 10 c4 ff ff jmp 1099d6 <_API_extensions_Add> <== NOT EXECUTED 0010d7ca <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 10d7ca: 55 push %ebp <== NOT EXECUTED 10d7cb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d7cd: 56 push %esi <== NOT EXECUTED 10d7ce: 53 push %ebx <== NOT EXECUTED 10d7cf: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d7d2: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi <== NOT EXECUTED ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 10d7d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d7db: 8d 86 90 00 00 00 lea 0x90(%esi),%eax <== NOT EXECUTED 10d7e1: 50 push %eax <== NOT EXECUTED 10d7e2: e8 99 0c 00 00 call 10e480 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10d7e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7ea: 85 c0 test %eax,%eax <== NOT EXECUTED 10d7ec: 75 02 jne 10d7f0 <_POSIX_Threads_Sporadic_budget_TSR+0x26> <== NOT EXECUTED 10d7ee: b0 01 mov $0x1,%al <== NOT EXECUTED ticks = 1; the_thread->cpu_time_budget = ticks; 10d7f0: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10d7f3: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10d7f8: 2b 86 98 00 00 00 sub 0x98(%esi),%eax <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; 10d7fe: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10d801: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) <== NOT EXECUTED 10d805: 74 05 je 10d80c <_POSIX_Threads_Sporadic_budget_TSR+0x42> <== NOT EXECUTED 10d807: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10d80a: 76 0d jbe 10d819 <_POSIX_Threads_Sporadic_budget_TSR+0x4f> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10d80c: 52 push %edx <== NOT EXECUTED 10d80d: 6a 01 push $0x1 <== NOT EXECUTED 10d80f: 50 push %eax <== NOT EXECUTED 10d810: 53 push %ebx <== NOT EXECUTED 10d811: e8 aa d1 ff ff call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED 10d816: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 10d819: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d81c: 8d 86 88 00 00 00 lea 0x88(%esi),%eax <== NOT EXECUTED 10d822: 50 push %eax <== NOT EXECUTED 10d823: e8 58 0c 00 00 call 10e480 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10d828: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d82b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d82d: 75 02 jne 10d831 <_POSIX_Threads_Sporadic_budget_TSR+0x67> <== NOT EXECUTED 10d82f: b0 01 mov $0x1,%al <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10d831: 89 86 a8 00 00 00 mov %eax,0xa8(%esi) <== NOT EXECUTED void *starting_address, size_t *size 10d837: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax <== NOT EXECUTED 10d83d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10d840: c7 45 08 58 d7 11 00 movl $0x11d758,0x8(%ebp) <== NOT EXECUTED ticks = 1; _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); } 10d847: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d84a: 5b pop %ebx <== NOT EXECUTED 10d84b: 5e pop %esi <== NOT EXECUTED 10d84c: c9 leave <== NOT EXECUTED 10d84d: e9 aa e3 ff ff jmp 10bbfc <_Watchdog_Insert> <== NOT EXECUTED 0010d78c <_POSIX_Threads_Sporadic_budget_callout>: */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10d78c: 55 push %ebp <== NOT EXECUTED 10d78d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d78f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d792: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d795: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax <== NOT EXECUTED * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 10d79b: c7 41 78 ff ff ff ff movl $0xffffffff,0x78(%ecx) <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10d7a2: ba ff 00 00 00 mov $0xff,%edx <== NOT EXECUTED 10d7a7: 2b 90 84 00 00 00 sub 0x84(%eax),%edx <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; 10d7ad: 89 51 18 mov %edx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10d7b0: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 10d7b4: 74 05 je 10d7bb <_POSIX_Threads_Sporadic_budget_callout+0x2f> <== NOT EXECUTED 10d7b6: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 10d7b9: 76 0d jbe 10d7c8 <_POSIX_Threads_Sporadic_budget_callout+0x3c> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10d7bb: 50 push %eax <== NOT EXECUTED 10d7bc: 6a 01 push $0x1 <== NOT EXECUTED 10d7be: 52 push %edx <== NOT EXECUTED 10d7bf: 51 push %ecx <== NOT EXECUTED 10d7c0: e8 fb d1 ff ff call 10a9c0 <_Thread_Change_priority> <== NOT EXECUTED 10d7c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d7c8: c9 leave <== NOT EXECUTED 10d7c9: c3 ret <== NOT EXECUTED 0010e96c <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 10e96c: 55 push %ebp <== NOT EXECUTED 10e96d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e96f: 57 push %edi <== NOT EXECUTED 10e970: 56 push %esi <== NOT EXECUTED 10e971: 53 push %ebx <== NOT EXECUTED 10e972: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e975: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e978: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 10e97e: c7 86 cc 00 00 00 01 movl $0x1,0xcc(%esi) <== NOT EXECUTED 10e985: 00 00 00 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10e988: 8d be dc 00 00 00 lea 0xdc(%esi),%edi <== NOT EXECUTED 10e98e: eb 26 jmp 10e9b6 <_POSIX_Threads_cancel_run+0x4a> <== NOT EXECUTED while ( !_Chain_Is_empty( handler_stack ) ) { _ISR_Disable( level ); 10e990: 9c pushf <== NOT EXECUTED 10e991: fa cli <== NOT EXECUTED 10e992: 59 pop %ecx <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 10e993: 8b 5f 04 mov 0x4(%edi),%ebx <== NOT EXECUTED 10e996: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10e998: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e99b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e99e: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10e9a0: 51 push %ecx <== NOT EXECUTED 10e9a1: 9d popf <== NOT EXECUTED (*handler->routine)( handler->arg ); 10e9a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e9a5: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10e9a8: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED _Workspace_Free( handler ); 10e9ab: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10e9ae: e8 35 d4 ff ff call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10e9b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 10e9b6: 39 be d8 00 00 00 cmp %edi,0xd8(%esi) <== NOT EXECUTED 10e9bc: 75 d2 jne 10e990 <_POSIX_Threads_cancel_run+0x24> <== NOT EXECUTED (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 10e9be: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e9c1: 5b pop %ebx <== NOT EXECUTED 10e9c2: 5e pop %esi <== NOT EXECUTED 10e9c3: 5f pop %edi <== NOT EXECUTED 10e9c4: c9 leave <== NOT EXECUTED 10e9c5: c3 ret <== NOT EXECUTED 0010f4ac <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 10f4ac: 55 push %ebp <== NOT EXECUTED 10f4ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f4af: 56 push %esi <== NOT EXECUTED 10f4b0: 53 push %ebx <== NOT EXECUTED 10f4b1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; (void) _Watchdog_Remove( timer ); 10f4b4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f4b7: 53 push %ebx <== NOT EXECUTED 10f4b8: e8 7b e2 ff ff call 10d738 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 10f4bd: 9c pushf <== NOT EXECUTED 10f4be: fa cli <== NOT EXECUTED 10f4bf: 5e pop %esi <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 10f4c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f4c3: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 10f4c7: 74 06 je 10f4cf <_POSIX_Timer_Insert_helper+0x23> <== NOT EXECUTED _ISR_Enable( level ); 10f4c9: 56 push %esi <== NOT EXECUTED 10f4ca: 9d popf <== NOT EXECUTED 10f4cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f4cd: eb 33 jmp 10f502 <_POSIX_Timer_Insert_helper+0x56> <== 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. * 10f4cf: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f4d6: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10f4d9: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10f4dc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f4df: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED * the heap 10f4e2: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10f4e5: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10f4e8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f4eb: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10f4ee: 50 push %eax <== NOT EXECUTED 10f4ef: 50 push %eax <== NOT EXECUTED 10f4f0: 53 push %ebx <== NOT EXECUTED 10f4f1: 68 10 1a 12 00 push $0x121a10 <== NOT EXECUTED 10f4f6: e8 25 e1 ff ff call 10d620 <_Watchdog_Insert> <== NOT EXECUTED * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 10f4fb: 56 push %esi <== NOT EXECUTED 10f4fc: 9d popf <== NOT EXECUTED 10f4fd: b0 01 mov $0x1,%al <== NOT EXECUTED 10f4ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 10f502: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f505: 5b pop %ebx <== NOT EXECUTED 10f506: 5e pop %esi <== NOT EXECUTED 10f507: c9 leave <== NOT EXECUTED 10f508: c3 ret <== NOT EXECUTED 0010d854 <_POSIX_Timer_Manager_initialization>: * Description: Initialize the internal structure in which the data of all * the timers are stored */ void _POSIX_Timer_Manager_initialization ( int maximum_timers ) { 10d854: 55 push %ebp <== NOT EXECUTED 10d855: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d857: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d85a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10d85f: 6a 01 push $0x1 <== NOT EXECUTED 10d861: 6a 74 push $0x74 <== NOT EXECUTED 10d863: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d866: 6a 09 push $0x9 <== NOT EXECUTED 10d868: 6a 03 push $0x3 <== NOT EXECUTED 10d86a: 68 a8 d9 11 00 push $0x11d9a8 <== NOT EXECUTED 10d86f: e8 84 ce ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d874: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d877: c9 leave <== NOT EXECUTED 10d878: c3 ret <== NOT EXECUTED 0010a2e4 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 10a2e4: 55 push %ebp <== NOT EXECUTED 10a2e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2e7: 53 push %ebx <== NOT EXECUTED 10a2e8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a2eb: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2ee: ff 43 68 incl 0x68(%ebx) <== NOT EXECUTED /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2f1: 83 7b 54 00 cmpl $0x0,0x54(%ebx) <== NOT EXECUTED 10a2f5: 75 06 jne 10a2fd <_POSIX_Timer_TSR+0x19> <== NOT EXECUTED 10a2f7: 83 7b 58 00 cmpl $0x0,0x58(%ebx) <== NOT EXECUTED 10a2fb: 74 34 je 10a331 <_POSIX_Timer_TSR+0x4d> <== NOT EXECUTED ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a300: 53 push %ebx <== NOT EXECUTED 10a301: 68 e4 a2 10 00 push $0x10a2e4 <== NOT EXECUTED 10a306: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a309: ff 73 64 pushl 0x64(%ebx) <== NOT EXECUTED 10a30c: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a30f: 50 push %eax <== NOT EXECUTED 10a310: e8 97 51 00 00 call 10f4ac <_POSIX_Timer_Insert_helper> <== NOT EXECUTED ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a315: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a318: 84 c0 test %al,%al <== NOT EXECUTED 10a31a: 74 30 je 10a34c <_POSIX_Timer_TSR+0x68> <== NOT EXECUTED return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a31c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a31f: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10a322: 50 push %eax <== NOT EXECUTED 10a323: e8 28 15 00 00 call 10b850 <_TOD_Get> <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a328: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED 10a32c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a32f: eb 04 jmp 10a335 <_POSIX_Timer_TSR+0x51> <== NOT EXECUTED } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a331: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10a335: 50 push %eax <== NOT EXECUTED 10a336: 50 push %eax <== NOT EXECUTED 10a337: ff 73 44 pushl 0x44(%ebx) <== NOT EXECUTED 10a33a: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 10a33d: e8 d6 4e 00 00 call 10f218 <== NOT EXECUTED } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a342: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED 10a349: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a34c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a34f: c9 leave <== NOT EXECUTED 10a350: c3 ret <== NOT EXECUTED 0010d52c <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 10d52c: 55 push %ebp <== NOT EXECUTED 10d52d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d52f: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED exit( 1 ); 10d532: 6a 01 push $0x1 <== NOT EXECUTED 10d534: e8 8b 1b 00 00 call 10f0c4 <== NOT EXECUTED 0010a77b <_POSIX_signals_Alarm_TSR>: void _POSIX_signals_Alarm_TSR( Objects_Id id, void *argument ) { 10a77b: 55 push %ebp <== NOT EXECUTED 10a77c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a77e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED int status; status = kill( getpid(), SIGALRM ); 10a781: e8 ca da ff ff call 108250 <== NOT EXECUTED 10a786: c7 45 0c 0e 00 00 00 movl $0xe,0xc(%ebp) <== NOT EXECUTED 10a78d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED /* XXX can't print from an ISR, should this be fatal? */ } 10a790: c9 leave <== NOT EXECUTED void *argument ) { int status; status = kill( getpid(), SIGALRM ); 10a791: e9 66 00 00 00 jmp 10a7fc <== NOT EXECUTED 0010ea70 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 10ea70: 55 push %ebp <== NOT EXECUTED 10ea71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ea73: 57 push %edi <== NOT EXECUTED 10ea74: 56 push %esi <== NOT EXECUTED 10ea75: 53 push %ebx <== NOT EXECUTED 10ea76: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10ea79: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ea7c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 10ea7f: 6a 01 push $0x1 <== NOT EXECUTED 10ea81: 0f b6 45 10 movzbl 0x10(%ebp),%eax <== NOT EXECUTED 10ea85: 50 push %eax <== NOT EXECUTED 10ea86: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10ea89: 50 push %eax <== NOT EXECUTED 10ea8a: 56 push %esi <== NOT EXECUTED 10ea8b: 57 push %edi <== NOT EXECUTED 10ea8c: e8 5f 00 00 00 call 10eaf0 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 10ea91: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ea94: 84 c0 test %al,%al <== NOT EXECUTED 10ea96: 74 4e je 10eae6 <_POSIX_signals_Check_signal+0x76> <== NOT EXECUTED #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 10ea98: 6b d6 0c imul $0xc,%esi,%edx <== NOT EXECUTED 10ea9b: 8b 8a 24 dc 11 00 mov 0x11dc24(%edx),%ecx <== NOT EXECUTED 10eaa1: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10eaa4: 74 40 je 10eae6 <_POSIX_signals_Check_signal+0x76> <== NOT EXECUTED return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 10eaa6: 8b 9f c4 00 00 00 mov 0xc4(%edi),%ebx <== NOT EXECUTED api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 10eaac: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10eaae: 0b 82 20 dc 11 00 or 0x11dc20(%edx),%eax <== NOT EXECUTED 10eab4: 89 87 c4 00 00 00 mov %eax,0xc4(%edi) <== NOT EXECUTED /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 10eaba: 83 ba 1c dc 11 00 02 cmpl $0x2,0x11dc1c(%edx) <== NOT EXECUTED 10eac1: 75 10 jne 10ead3 <_POSIX_signals_Check_signal+0x63> <== NOT EXECUTED case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 10eac3: 50 push %eax <== NOT EXECUTED 10eac4: 6a 00 push $0x0 <== NOT EXECUTED 10eac6: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10eac9: 50 push %eax <== NOT EXECUTED 10eaca: 56 push %esi <== NOT EXECUTED 10eacb: ff 92 24 dc 11 00 call *0x11dc24(%edx) <== NOT EXECUTED 10ead1: eb 06 jmp 10ead9 <_POSIX_signals_Check_signal+0x69> <== NOT EXECUTED &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 10ead3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ead6: 56 push %esi <== NOT EXECUTED 10ead7: ff d1 call *%ecx <== NOT EXECUTED 10ead9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 10eadc: 89 9f c4 00 00 00 mov %ebx,0xc4(%edi) <== NOT EXECUTED 10eae2: b0 01 mov $0x1,%al <== NOT EXECUTED 10eae4: eb 02 jmp 10eae8 <_POSIX_signals_Check_signal+0x78> <== NOT EXECUTED return true; 10eae6: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10eae8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10eaeb: 5b pop %ebx <== NOT EXECUTED 10eaec: 5e pop %esi <== NOT EXECUTED 10eaed: 5f pop %edi <== NOT EXECUTED 10eaee: c9 leave <== NOT EXECUTED 10eaef: c3 ret <== NOT EXECUTED 0010f07c <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) { 10f07c: 55 push %ebp <== NOT EXECUTED 10f07d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f07f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10f082: 9c pushf <== NOT EXECUTED 10f083: fa cli <== NOT EXECUTED 10f084: 5a pop %edx <== NOT EXECUTED _POSIX_signals_Pending &= ~mask; 10f085: f7 d0 not %eax <== NOT EXECUTED 10f087: 23 05 e8 dd 11 00 and 0x11dde8,%eax <== NOT EXECUTED 10f08d: a3 e8 dd 11 00 mov %eax,0x11dde8 <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 10f092: 85 c0 test %eax,%eax <== NOT EXECUTED 10f094: 75 06 jne 10f09c <_POSIX_signals_Clear_process_signals+0x20> <== NOT EXECUTED _Thread_Do_post_task_switch_extension--; 10f096: ff 0d 1c d7 11 00 decl 0x11d71c <== NOT EXECUTED _ISR_Enable( level ); 10f09c: 52 push %edx <== NOT EXECUTED 10f09d: 9d popf <== NOT EXECUTED } 10f09e: c9 leave <== NOT EXECUTED 10f09f: c3 ret <== NOT EXECUTED 0010eaf0 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 10eaf0: 55 push %ebp <== NOT EXECUTED 10eaf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eaf3: 57 push %edi <== NOT EXECUTED 10eaf4: 56 push %esi <== NOT EXECUTED 10eaf5: 53 push %ebx <== NOT EXECUTED 10eaf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eaf9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10eafc: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10eaff: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 10eb02: 8d 4f ff lea -0x1(%edi),%ecx <== NOT EXECUTED 10eb05: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 10eb0a: d3 e6 shl %cl,%esi <== NOT EXECUTED /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 10eb0c: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10eb0f: 80 7d 18 00 cmpb $0x0,0x18(%ebp) <== NOT EXECUTED 10eb13: 74 08 je 10eb1d <_POSIX_signals_Clear_signals+0x2d> <== NOT EXECUTED signals_blocked = ~api->signals_blocked; 10eb15: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx <== NOT EXECUTED 10eb1b: f7 d2 not %edx <== NOT EXECUTED signals_blocked = SIGNAL_ALL_MASK; /* XXX this is not right for siginfo type signals yet */ /* XXX since they can't be cleared the same way */ _ISR_Disable( level ); 10eb1d: 9c pushf <== NOT EXECUTED 10eb1e: fa cli <== NOT EXECUTED 10eb1f: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( is_global ) { 10eb22: 84 c0 test %al,%al <== NOT EXECUTED 10eb24: 0f 84 8d 00 00 00 je 10ebb7 <_POSIX_signals_Clear_signals+0xc7> <== NOT EXECUTED if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 10eb2a: 89 f0 mov %esi,%eax <== NOT EXECUTED 10eb2c: 23 05 e8 dd 11 00 and 0x11dde8,%eax <== NOT EXECUTED 10eb32: 85 d0 test %edx,%eax <== NOT EXECUTED 10eb34: 0f 84 9b 00 00 00 je 10ebd5 <_POSIX_signals_Clear_signals+0xe5> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 10eb3a: 6b d7 0c imul $0xc,%edi,%edx <== NOT EXECUTED 10eb3d: 83 ba 1c dc 11 00 02 cmpl $0x2,0x11dc1c(%edx) <== NOT EXECUTED 10eb44: 75 61 jne 10eba7 <_POSIX_signals_Clear_signals+0xb7> <== NOT EXECUTED psiginfo = (POSIX_signals_Siginfo_node *) 10eb46: 8d 8a ec dd 11 00 lea 0x11ddec(%edx),%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( 10eb4c: 8b 9a ec dd 11 00 mov 0x11ddec(%edx),%ebx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10eb52: 8d 79 04 lea 0x4(%ecx),%edi <== NOT EXECUTED 10eb55: 39 fb cmp %edi,%ebx <== NOT EXECUTED 10eb57: 75 04 jne 10eb5d <_POSIX_signals_Clear_signals+0x6d> <== NOT EXECUTED 10eb59: 31 db xor %ebx,%ebx <== NOT EXECUTED 10eb5b: eb 0b jmp 10eb68 <_POSIX_signals_Clear_signals+0x78> <== NOT EXECUTED 10eb5d: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10eb5f: 89 82 ec dd 11 00 mov %eax,0x11ddec(%edx) <== NOT EXECUTED 10eb65: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 10eb68: 39 ba ec dd 11 00 cmp %edi,0x11ddec(%edx) <== NOT EXECUTED 10eb6e: 75 0c jne 10eb7c <_POSIX_signals_Clear_signals+0x8c> <== NOT EXECUTED _POSIX_signals_Clear_process_signals( mask ); 10eb70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb73: 56 push %esi <== NOT EXECUTED 10eb74: e8 03 05 00 00 call 10f07c <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 10eb79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( psiginfo ) { 10eb7c: b0 01 mov $0x1,%al <== NOT EXECUTED 10eb7e: 85 db test %ebx,%ebx <== NOT EXECUTED 10eb80: 74 55 je 10ebd7 <_POSIX_signals_Clear_signals+0xe7> <== NOT EXECUTED *info = psiginfo->Info; 10eb82: 8d 73 08 lea 0x8(%ebx),%esi <== NOT EXECUTED 10eb85: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10eb8a: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10eb8d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10eb8f: c7 03 a0 dd 11 00 movl $0x11dda0,(%ebx) <== NOT EXECUTED 10eb95: a1 a4 dd 11 00 mov 0x11dda4,%eax <== NOT EXECUTED 10eb9a: 89 1d a4 dd 11 00 mov %ebx,0x11dda4 <== NOT EXECUTED 10eba0: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10eba2: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10eba5: eb 2a jmp 10ebd1 <_POSIX_signals_Clear_signals+0xe1> <== NOT EXECUTED &psiginfo->Node ); } else do_callout = false; } else _POSIX_signals_Clear_process_signals( mask ); 10eba7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ebaa: 56 push %esi <== NOT EXECUTED 10ebab: e8 cc 04 00 00 call 10f07c <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 10ebb0: b0 01 mov $0x1,%al <== NOT EXECUTED 10ebb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ebb5: eb 20 jmp 10ebd7 <_POSIX_signals_Clear_signals+0xe7> <== NOT EXECUTED do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 10ebb7: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED 10ebbd: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ebbf: 21 c8 and %ecx,%eax <== NOT EXECUTED 10ebc1: 85 d0 test %edx,%eax <== NOT EXECUTED 10ebc3: 74 10 je 10ebd5 <_POSIX_signals_Clear_signals+0xe5> <== NOT EXECUTED api->signals_pending &= ~mask; 10ebc5: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ebc7: f7 d0 not %eax <== NOT EXECUTED 10ebc9: 21 c8 and %ecx,%eax <== NOT EXECUTED 10ebcb: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx) <== NOT EXECUTED 10ebd1: b0 01 mov $0x1,%al <== NOT EXECUTED 10ebd3: eb 02 jmp 10ebd7 <_POSIX_signals_Clear_signals+0xe7> <== NOT EXECUTED 10ebd5: 31 c0 xor %eax,%eax <== NOT EXECUTED do_callout = true; } } _ISR_Enable( level ); 10ebd7: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10ebda: 9d popf <== NOT EXECUTED return do_callout; } 10ebdb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebde: 5b pop %ebx <== NOT EXECUTED 10ebdf: 5e pop %esi <== NOT EXECUTED 10ebe0: 5f pop %edi <== NOT EXECUTED 10ebe1: c9 leave <== NOT EXECUTED 10ebe2: c3 ret <== NOT EXECUTED 001099d0 <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 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 1099d8: b8 1b 00 00 00 mov $0x1b,%eax <== NOT EXECUTED int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 1099dd: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 1099e2: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 1099e5: 89 d6 mov %edx,%esi <== NOT EXECUTED 1099e7: d3 e6 shl %cl,%esi <== NOT EXECUTED 1099e9: 85 de test %ebx,%esi <== NOT EXECUTED 1099eb: 75 20 jne 109a0d <_POSIX_signals_Get_highest+0x3d> <== NOT EXECUTED sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 1099ed: 40 inc %eax <== NOT EXECUTED 1099ee: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 1099f1: 75 ef jne 1099e2 <_POSIX_signals_Get_highest+0x12> <== NOT EXECUTED 1099f3: b0 01 mov $0x1,%al <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 1099f5: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 1099fa: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 1099fd: 89 d6 mov %edx,%esi <== NOT EXECUTED 1099ff: d3 e6 shl %cl,%esi <== NOT EXECUTED 109a01: 85 de test %ebx,%esi <== NOT EXECUTED 109a03: 75 08 jne 109a0d <_POSIX_signals_Get_highest+0x3d> <== NOT EXECUTED return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 109a05: 40 inc %eax <== NOT EXECUTED 109a06: 83 f8 1b cmp $0x1b,%eax <== NOT EXECUTED 109a09: 75 ef jne 1099fa <_POSIX_signals_Get_highest+0x2a> <== NOT EXECUTED 109a0b: 30 c0 xor %al,%al <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 109a0d: 5b pop %ebx <== NOT EXECUTED 109a0e: 5e pop %esi <== NOT EXECUTED 109a0f: c9 leave <== NOT EXECUTED 109a10: c3 ret <== NOT EXECUTED 0010d3f4 <_POSIX_signals_Manager_Initialization>: */ void _POSIX_signals_Manager_Initialization( int maximum_queued_signals ) { 10d3f4: 55 push %ebp <== NOT EXECUTED 10d3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3f7: 57 push %edi <== NOT EXECUTED 10d3f8: 56 push %esi <== NOT EXECUTED 10d3f9: 53 push %ebx <== NOT EXECUTED 10d3fa: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10d3fd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED assert( sizeof(_POSIX_signals_Vectors) == sizeof(_POSIX_signals_Default_vectors) ); memcpy( 10d400: bf 1c dc 11 00 mov $0x11dc1c,%edi <== NOT EXECUTED 10d405: be a4 76 11 00 mov $0x1176a4,%esi <== NOT EXECUTED 10d40a: b9 60 00 00 00 mov $0x60,%ecx <== NOT EXECUTED 10d40f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Initialize the set of pending signals for the entire process */ sigemptyset( &_POSIX_signals_Pending ); 10d411: 68 e8 dd 11 00 push $0x11dde8 <== NOT EXECUTED 10d416: e8 89 04 00 00 call 10d8a4 <== NOT EXECUTED /* * Initialize the queue we use to block for signals */ _Thread_queue_Initialize( 10d41b: 6a 0b push $0xb <== NOT EXECUTED 10d41d: 68 00 80 00 10 push $0x10008000 <== NOT EXECUTED 10d422: 6a 01 push $0x1 <== NOT EXECUTED 10d424: 68 a8 dd 11 00 push $0x11dda8 <== NOT EXECUTED 10d429: e8 b6 e0 ff ff call 10b4e4 <_Thread_queue_Initialize> <== NOT EXECUTED 10d42e: ba f8 dd 11 00 mov $0x11ddf8,%edx <== NOT EXECUTED 10d433: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10d436: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10d439: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10d43b: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10d442: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10d445: 83 c2 0c add $0xc,%edx <== NOT EXECUTED /* * Allocate the siginfo pools. */ for ( signo=1 ; signo<= SIGRTMAX ; signo++ ) 10d448: 81 fa 6c df 11 00 cmp $0x11df6c,%edx <== NOT EXECUTED 10d44e: 75 e6 jne 10d436 <_POSIX_signals_Manager_Initialization+0x42> <== NOT EXECUTED _Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] ); if ( maximum_queued_signals ) { 10d450: 85 db test %ebx,%ebx <== NOT EXECUTED 10d452: 74 1f je 10d473 <_POSIX_signals_Manager_Initialization+0x7f> <== NOT EXECUTED _Chain_Initialize( 10d454: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d457: 6b c3 14 imul $0x14,%ebx,%eax <== NOT EXECUTED 10d45a: 50 push %eax <== NOT EXECUTED 10d45b: e8 b2 e9 ff ff call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10d460: 6a 14 push $0x14 <== NOT EXECUTED 10d462: 53 push %ebx <== NOT EXECUTED 10d463: 50 push %eax <== NOT EXECUTED 10d464: 68 9c dd 11 00 push $0x11dd9c <== NOT EXECUTED 10d469: e8 7e 08 00 00 call 10dcec <_Chain_Initialize> <== NOT EXECUTED 10d46e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10d471: eb 1e jmp 10d491 <_POSIX_signals_Manager_Initialization+0x9d> <== NOT EXECUTED 10d473: c7 05 9c dd 11 00 a0 movl $0x11dda0,0x11dd9c <== NOT EXECUTED 10d47a: dd 11 00 <== NOT EXECUTED 10d47d: c7 05 a0 dd 11 00 00 movl $0x0,0x11dda0 <== NOT EXECUTED 10d484: 00 00 00 <== NOT EXECUTED 10d487: c7 05 a4 dd 11 00 9c movl $0x11dd9c,0x11dda4 <== NOT EXECUTED 10d48e: dd 11 00 <== NOT EXECUTED sizeof( POSIX_signals_Siginfo_node ) ); } else { _Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo ); } } 10d491: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d494: 5b pop %ebx <== NOT EXECUTED 10d495: 5e pop %esi <== NOT EXECUTED 10d496: 5f pop %edi <== NOT EXECUTED 10d497: c9 leave <== NOT EXECUTED 10d498: c3 ret <== NOT EXECUTED 0010d499 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 10d499: 55 push %ebp <== NOT EXECUTED 10d49a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d49c: 56 push %esi <== NOT EXECUTED 10d49d: 53 push %ebx <== NOT EXECUTED POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d49e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d4a1: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi <== NOT EXECUTED if ( !api ) 10d4a7: 85 f6 test %esi,%esi <== NOT EXECUTED 10d4a9: 74 7a je 10d525 <_POSIX_signals_Post_switch_extension+0x8c> <== NOT EXECUTED * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 10d4ab: 9c pushf <== NOT EXECUTED 10d4ac: fa cli <== NOT EXECUTED 10d4ad: 59 pop %ecx <== NOT EXECUTED if ( !(~api->signals_blocked & 10d4ae: 8b 15 e8 dd 11 00 mov 0x11dde8,%edx <== NOT EXECUTED 10d4b4: 0b 96 c8 00 00 00 or 0xc8(%esi),%edx <== NOT EXECUTED 10d4ba: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 10d4c0: f7 d0 not %eax <== NOT EXECUTED 10d4c2: 85 c2 test %eax,%edx <== NOT EXECUTED 10d4c4: 75 04 jne 10d4ca <_POSIX_signals_Post_switch_extension+0x31> <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 10d4c6: 51 push %ecx <== NOT EXECUTED 10d4c7: 9d popf <== NOT EXECUTED 10d4c8: eb 5b jmp 10d525 <_POSIX_signals_Post_switch_extension+0x8c> <== NOT EXECUTED break; } _ISR_Enable( level ); 10d4ca: 51 push %ecx <== NOT EXECUTED 10d4cb: 9d popf <== NOT EXECUTED 10d4cc: bb 1b 00 00 00 mov $0x1b,%ebx <== NOT EXECUTED for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10d4d1: 50 push %eax <== NOT EXECUTED 10d4d2: 6a 00 push $0x0 <== NOT EXECUTED 10d4d4: 53 push %ebx <== NOT EXECUTED 10d4d5: 56 push %esi <== NOT EXECUTED 10d4d6: e8 95 15 00 00 call 10ea70 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10d4db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4de: 84 c0 test %al,%al <== NOT EXECUTED 10d4e0: 75 c9 jne 10d4ab <_POSIX_signals_Post_switch_extension+0x12> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10d4e2: 51 push %ecx <== NOT EXECUTED 10d4e3: 6a 01 push $0x1 <== NOT EXECUTED 10d4e5: 53 push %ebx <== NOT EXECUTED 10d4e6: 56 push %esi <== NOT EXECUTED 10d4e7: e8 84 15 00 00 call 10ea70 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10d4ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4ef: 84 c0 test %al,%al <== NOT EXECUTED 10d4f1: 75 b8 jne 10d4ab <_POSIX_signals_Post_switch_extension+0x12> <== NOT EXECUTED _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10d4f3: 43 inc %ebx <== NOT EXECUTED 10d4f4: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10d4f7: 75 d8 jne 10d4d1 <_POSIX_signals_Post_switch_extension+0x38> <== NOT EXECUTED 10d4f9: b3 01 mov $0x1,%bl <== NOT EXECUTED /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10d4fb: 52 push %edx <== NOT EXECUTED 10d4fc: 6a 00 push $0x0 <== NOT EXECUTED 10d4fe: 53 push %ebx <== NOT EXECUTED 10d4ff: 56 push %esi <== NOT EXECUTED 10d500: e8 6b 15 00 00 call 10ea70 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10d505: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d508: 84 c0 test %al,%al <== NOT EXECUTED 10d50a: 75 9f jne 10d4ab <_POSIX_signals_Post_switch_extension+0x12> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10d50c: 50 push %eax <== NOT EXECUTED 10d50d: 6a 01 push $0x1 <== NOT EXECUTED 10d50f: 53 push %ebx <== NOT EXECUTED 10d510: 56 push %esi <== NOT EXECUTED 10d511: e8 5a 15 00 00 call 10ea70 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10d516: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d519: 84 c0 test %al,%al <== NOT EXECUTED 10d51b: 75 8e jne 10d4ab <_POSIX_signals_Post_switch_extension+0x12> <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10d51d: 43 inc %ebx <== NOT EXECUTED 10d51e: 83 fb 1b cmp $0x1b,%ebx <== NOT EXECUTED 10d521: 75 d8 jne 10d4fb <_POSIX_signals_Post_switch_extension+0x62> <== NOT EXECUTED 10d523: eb 86 jmp 10d4ab <_POSIX_signals_Post_switch_extension+0x12> <== NOT EXECUTED goto restart; } } return; } 10d525: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d528: 5b pop %ebx <== NOT EXECUTED 10d529: 5e pop %esi <== NOT EXECUTED 10d52a: c9 leave <== NOT EXECUTED 10d52b: c3 ret <== NOT EXECUTED 0011e2b8 <_POSIX_signals_Set_process_signals>: */ void _POSIX_signals_Set_process_signals( sigset_t mask ) { 11e2b8: 55 push %ebp <== NOT EXECUTED 11e2b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e2bb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 11e2be: 9c pushf <== NOT EXECUTED 11e2bf: fa cli <== NOT EXECUTED 11e2c0: 59 pop %ecx <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 11e2c1: 8b 15 44 a1 12 00 mov 0x12a144,%edx <== NOT EXECUTED 11e2c7: 85 d2 test %edx,%edx <== NOT EXECUTED 11e2c9: 75 06 jne 11e2d1 <_POSIX_signals_Set_process_signals+0x19> <== NOT EXECUTED _Thread_Do_post_task_switch_extension++; 11e2cb: ff 05 00 9a 12 00 incl 0x129a00 <== NOT EXECUTED _POSIX_signals_Pending |= mask; 11e2d1: 09 d0 or %edx,%eax <== NOT EXECUTED 11e2d3: a3 44 a1 12 00 mov %eax,0x12a144 <== NOT EXECUTED _ISR_Enable( level ); 11e2d8: 51 push %ecx <== NOT EXECUTED 11e2d9: 9d popf <== NOT EXECUTED } 11e2da: c9 leave <== NOT EXECUTED 11e2db: c3 ret <== NOT EXECUTED 00108e5c <_POSIX_signals_Ualarm_TSR>: void _POSIX_signals_Ualarm_TSR( Objects_Id id, void *argument ) { 108e5c: 55 push %ebp <== NOT EXECUTED 108e5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e5f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * Send a SIGALRM but if there is a problem, ignore it. * It's OK, there isn't a way this should fail. */ (void) kill( getpid(), SIGALRM ); 108e62: e8 49 d8 ff ff call 1066b0 <== NOT EXECUTED 108e67: 52 push %edx <== NOT EXECUTED 108e68: 52 push %edx <== NOT EXECUTED 108e69: 6a 0e push $0xe <== NOT EXECUTED 108e6b: 50 push %eax <== NOT EXECUTED 108e6c: e8 2f fd ff ff call 108ba0 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information_block *the_info ); /** * This heap routine returns information about the free blocks 108e71: c7 04 24 b0 fd 11 00 movl $0x11fdb0,(%esp) <== NOT EXECUTED 108e78: e8 5f 34 00 00 call 10c2dc <_Watchdog_Remove> <== NOT EXECUTED * in the specified heap. * 108e7d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e80: c7 45 0c b0 fd 11 00 movl $0x11fdb0,0xc(%ebp) <== NOT EXECUTED 108e87: c7 45 08 70 ff 11 00 movl $0x11ff70,0x8(%ebp) <== NOT EXECUTED /* * If the reset interval is non-zero, reschedule ourselves. */ _Watchdog_Reset( &_POSIX_signals_Ualarm_timer ); } 108e8e: c9 leave <== NOT EXECUTED 108e8f: e9 30 33 00 00 jmp 10c1c4 <_Watchdog_Insert> <== NOT EXECUTED 0011e2dc <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 11e2dc: 55 push %ebp <== NOT EXECUTED 11e2dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e2df: 57 push %edi <== NOT EXECUTED 11e2e0: 56 push %esi <== NOT EXECUTED 11e2e1: 53 push %ebx <== NOT EXECUTED 11e2e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e2e5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 11e2e8: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11e2eb: 8b bb f8 00 00 00 mov 0xf8(%ebx),%edi <== NOT EXECUTED mask = signo_to_mask( signo ); 11e2f1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11e2f4: 49 dec %ecx <== NOT EXECUTED 11e2f5: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 11e2fa: d3 e2 shl %cl,%edx <== NOT EXECUTED /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 11e2fc: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 11e2ff: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11e301: 25 00 80 00 10 and $0x10008000,%eax <== NOT EXECUTED 11e306: 3d 00 80 00 10 cmp $0x10008000,%eax <== NOT EXECUTED 11e30b: 75 4c jne 11e359 <_POSIX_signals_Unblock_thread+0x7d> <== NOT EXECUTED if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 11e30d: 85 53 30 test %edx,0x30(%ebx) <== NOT EXECUTED 11e310: 75 10 jne 11e322 <_POSIX_signals_Unblock_thread+0x46> <== NOT EXECUTED 11e312: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 11e318: f7 d0 not %eax <== NOT EXECUTED 11e31a: 85 c2 test %eax,%edx <== NOT EXECUTED 11e31c: 0f 84 a0 00 00 00 je 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 11e322: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED the_info = (siginfo_t *) the_thread->Wait.return_argument; 11e329: 8b 7b 28 mov 0x28(%ebx),%edi <== NOT EXECUTED if ( !info ) { 11e32c: 85 f6 test %esi,%esi <== NOT EXECUTED 11e32e: 75 15 jne 11e345 <_POSIX_signals_Unblock_thread+0x69> <== NOT EXECUTED the_info->si_signo = signo; 11e330: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11e333: 89 07 mov %eax,(%edi) <== NOT EXECUTED the_info->si_code = SI_USER; 11e335: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 11e33c: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) <== NOT EXECUTED 11e343: eb 07 jmp 11e34c <_POSIX_signals_Unblock_thread+0x70> <== NOT EXECUTED } else { *the_info = *info; 11e345: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 11e34a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } _Thread_queue_Extract_with_proxy( the_thread ); 11e34c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e34f: 53 push %ebx <== NOT EXECUTED 11e350: e8 d3 07 ff ff call 10eb28 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 11e355: b0 01 mov $0x1,%al <== NOT EXECUTED 11e357: eb 48 jmp 11e3a1 <_POSIX_signals_Unblock_thread+0xc5> <== NOT EXECUTED } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 11e359: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 11e35f: f7 d0 not %eax <== NOT EXECUTED 11e361: 85 c2 test %eax,%edx <== NOT EXECUTED 11e363: 74 5d je 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ the_thread->do_post_task_switch_extension = true; 11e365: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 11e369: f7 c1 00 00 00 10 test $0x10000000,%ecx <== NOT EXECUTED 11e36f: 74 35 je 11e3a6 <_POSIX_signals_Unblock_thread+0xca> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 11e371: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED #if 0 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ 11e378: 80 e1 08 and $0x8,%cl <== NOT EXECUTED 11e37b: 74 45 je 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 11e37d: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 11e381: 75 0f jne 11e392 <_POSIX_signals_Unblock_thread+0xb6> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 11e383: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e386: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 11e389: 50 push %eax <== NOT EXECUTED 11e38a: e8 a5 10 ff ff call 10f434 <_Watchdog_Remove> <== NOT EXECUTED 11e38f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 11e392: 50 push %eax <== NOT EXECUTED 11e393: 50 push %eax <== NOT EXECUTED 11e394: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 11e399: 53 push %ebx <== NOT EXECUTED 11e39a: e8 a9 fd fe ff call 10e148 <_Thread_Clear_state> <== NOT EXECUTED 11e39f: 31 c0 xor %eax,%eax <== NOT EXECUTED 11e3a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e3a4: eb 1e jmp 11e3c4 <_POSIX_signals_Unblock_thread+0xe8> <== NOT EXECUTED _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 11e3a6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11e3a8: 75 18 jne 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11e3aa: a1 f8 99 12 00 mov 0x1299f8,%eax <== NOT EXECUTED 11e3af: 85 c0 test %eax,%eax <== NOT EXECUTED 11e3b1: 74 0f je 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED 11e3b3: 3b 1d 1c 9a 12 00 cmp 0x129a1c,%ebx <== NOT EXECUTED 11e3b9: 75 07 jne 11e3c2 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 11e3bb: c6 05 b0 9a 12 00 01 movb $0x1,0x129ab0 <== NOT EXECUTED 11e3c2: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return false; } 11e3c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e3c7: 5b pop %ebx <== NOT EXECUTED 11e3c8: 5e pop %esi <== NOT EXECUTED 11e3c9: 5f pop %edi <== NOT EXECUTED 11e3ca: c9 leave <== NOT EXECUTED 11e3cb: c3 ret <== NOT EXECUTED 0010d954 <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10d954: 55 push %ebp <== NOT EXECUTED 10d955: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d95a: 6a 04 push $0x4 <== NOT EXECUTED 10d95c: 6a 00 push $0x0 <== NOT EXECUTED 10d95e: 6a 30 push $0x30 <== NOT EXECUTED 10d960: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d963: 6a 05 push $0x5 <== NOT EXECUTED 10d965: 6a 02 push $0x2 <== NOT EXECUTED 10d967: 68 78 e0 11 00 push $0x11e078 <== NOT EXECUTED 10d96c: e8 87 cd ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d971: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10d974: c9 leave <== NOT EXECUTED 10d975: c3 ret <== NOT EXECUTED 0010a90c <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10a90c: 55 push %ebp <== NOT EXECUTED 10a90d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a90f: 53 push %ebx <== NOT EXECUTED 10a910: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10a913: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10a919: e8 2e f1 ff ff call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10a91e: 5a pop %edx <== NOT EXECUTED 10a91f: 59 pop %ecx <== NOT EXECUTED 10a920: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a923: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a926: e8 f5 35 00 00 call 10df20 <_Heap_Allocate> <== NOT EXECUTED 10a92b: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a92d: 58 pop %eax <== NOT EXECUTED 10a92e: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10a934: e8 5b f1 ff ff call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10a939: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a93b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a93e: c9 leave <== NOT EXECUTED 10a93f: c3 ret <== NOT EXECUTED 0010c610 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10c610: 55 push %ebp <== NOT EXECUTED 10c611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c613: 53 push %ebx <== NOT EXECUTED 10c614: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10c617: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c61d: e8 9a eb ff ff call 10b1bc <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10c622: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c625: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c628: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c62b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c62e: e8 99 f1 ff ff call 10b7cc <_Heap_Allocate_aligned> <== NOT EXECUTED 10c633: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c635: 58 pop %eax <== NOT EXECUTED 10c636: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c63c: e8 c3 eb ff ff call 10b204 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10c641: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c643: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c646: c9 leave <== NOT EXECUTED 10c647: c3 ret <== NOT EXECUTED 0010c67c <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10c67c: 55 push %ebp <== NOT EXECUTED 10c67d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c67f: 53 push %ebx <== NOT EXECUTED 10c680: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10c683: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c689: e8 2e eb ff ff call 10b1bc <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10c68e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c691: 50 push %eax <== NOT EXECUTED 10c692: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c695: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c698: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c69b: e8 58 38 00 00 call 10fef8 <_Heap_Extend> <== NOT EXECUTED 10c6a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c6a2: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10c6a5: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c6ab: e8 54 eb ff ff call 10b204 <_API_Mutex_Unlock> <== NOT EXECUTED 10c6b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6b3: 85 db test %ebx,%ebx <== NOT EXECUTED 10c6b5: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10c6b8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c6bb: c9 leave <== NOT EXECUTED 10c6bc: c3 ret <== NOT EXECUTED 0010a940 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10a940: 55 push %ebp <== NOT EXECUTED 10a941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a943: 53 push %ebx <== NOT EXECUTED 10a944: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10a947: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10a94d: e8 fa f0 ff ff call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10a952: 5a pop %edx <== NOT EXECUTED 10a953: 59 pop %ecx <== NOT EXECUTED 10a954: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a957: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a95a: e8 2d 36 00 00 call 10df8c <_Heap_Free> <== NOT EXECUTED 10a95f: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a961: 58 pop %eax <== NOT EXECUTED 10a962: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10a968: e8 27 f1 ff ff call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10a96d: 88 d8 mov %bl,%al <== NOT EXECUTED 10a96f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a972: c9 leave <== NOT EXECUTED 10a973: c3 ret <== NOT EXECUTED 00115964 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 115964: 55 push %ebp <== NOT EXECUTED 115965: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115967: 53 push %ebx <== NOT EXECUTED 115968: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 11596b: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 115971: e8 d6 40 ff ff call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 115976: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115979: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11597c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11597f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115982: e8 4d 02 00 00 call 115bd4 <_Heap_Size_of_user_area> <== NOT EXECUTED 115987: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 115989: 58 pop %eax <== NOT EXECUTED 11598a: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 115990: e8 ff 40 ff ff call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 115995: 88 d8 mov %bl,%al <== NOT EXECUTED 115997: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11599a: c9 leave <== NOT EXECUTED 11599b: c3 ret <== NOT EXECUTED 0010f47c <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 10f47c: 55 push %ebp <== NOT EXECUTED 10f47d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f47f: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 10f482: ff 35 84 ad 15 00 pushl 0x15ad84 <== NOT EXECUTED 10f488: e8 d3 ec ff ff call 10e160 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 10f48d: 5a pop %edx <== NOT EXECUTED 10f48e: 59 pop %ecx <== NOT EXECUTED 10f48f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f492: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f495: e8 4a 2d 01 00 call 1221e4 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10f49a: 58 pop %eax <== NOT EXECUTED 10f49b: ff 35 84 ad 15 00 pushl 0x15ad84 <== NOT EXECUTED 10f4a1: e8 02 ed ff ff call 10e1a8 <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 10f4a6: b0 01 mov $0x1,%al <== NOT EXECUTED 10f4a8: c9 leave <== NOT EXECUTED 10f4a9: c3 ret <== NOT EXECUTED 001224b4 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 1224b4: 55 push %ebp <== NOT EXECUTED 1224b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1224b7: 56 push %esi <== NOT EXECUTED 1224b8: 53 push %ebx <== NOT EXECUTED 1224b9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1224bc: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 1224bf: 85 f6 test %esi,%esi <== NOT EXECUTED 1224c1: 74 33 je 1224f6 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; if ( !the_info ) 1224c3: 85 db test %ebx,%ebx <== NOT EXECUTED 1224c5: 74 2f je 1224f6 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 1224c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1224ca: ff 35 84 ad 15 00 pushl 0x15ad84 <== NOT EXECUTED 1224d0: e8 8b bc fe ff call 10e160 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 1224d5: 5a pop %edx <== NOT EXECUTED 1224d6: 59 pop %ecx <== NOT EXECUTED 1224d7: 53 push %ebx <== NOT EXECUTED 1224d8: 56 push %esi <== NOT EXECUTED 1224d9: e8 92 7b 00 00 call 12a070 <_Heap_Get_information> <== NOT EXECUTED 1224de: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1224e0: 58 pop %eax <== NOT EXECUTED 1224e1: ff 35 84 ad 15 00 pushl 0x15ad84 <== NOT EXECUTED 1224e7: e8 bc bc fe ff call 10e1a8 <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 1224ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1224ef: 85 db test %ebx,%ebx <== NOT EXECUTED 1224f1: 0f 94 c0 sete %al <== NOT EXECUTED 1224f4: eb 02 jmp 1224f8 <_Protected_heap_Get_information+0x44> <== NOT EXECUTED 1224f6: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 1224f8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1224fb: 5b pop %ebx <== NOT EXECUTED 1224fc: 5e pop %esi <== NOT EXECUTED 1224fd: c9 leave <== NOT EXECUTED 1224fe: c3 ret <== NOT EXECUTED 0011599c <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 11599c: 55 push %ebp <== NOT EXECUTED 11599d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11599f: 53 push %ebx <== NOT EXECUTED 1159a0: 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(); 1159a3: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 1159a9: e8 9e 40 ff ff call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 1159ae: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1159b1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1159b4: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1159b7: 50 push %eax <== NOT EXECUTED 1159b8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1159bb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1159be: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1159c1: e8 1e 00 00 00 call 1159e4 <_Heap_Resize_block> <== NOT EXECUTED 1159c6: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 1159c8: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 1159cb: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 1159d1: e8 be 40 ff ff call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED 1159d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1159d9: 85 db test %ebx,%ebx <== NOT EXECUTED 1159db: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 1159de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1159e1: c9 leave <== NOT EXECUTED 1159e2: c3 ret <== NOT EXECUTED 0010c7f0 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10c7f0: 55 push %ebp <== NOT EXECUTED 10c7f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7f3: 57 push %edi <== NOT EXECUTED 10c7f4: 56 push %esi <== NOT EXECUTED 10c7f5: 53 push %ebx <== NOT EXECUTED 10c7f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c7f9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c7fc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c7ff: 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 ) { 10c802: a1 a4 19 12 00 mov 0x1219a4,%eax <== NOT EXECUTED 10c807: 85 c0 test %eax,%eax <== NOT EXECUTED 10c809: 75 37 jne 10c842 <_Protected_heap_Walk+0x52> <== NOT EXECUTED _RTEMS_Lock_allocator(); 10c80b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c80e: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c814: e8 a3 e9 ff ff call 10b1bc <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10c819: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c81c: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c81f: 50 push %eax <== NOT EXECUTED 10c820: 56 push %esi <== NOT EXECUTED 10c821: 57 push %edi <== NOT EXECUTED 10c822: e8 89 38 00 00 call 1100b0 <_Heap_Walk> <== NOT EXECUTED 10c827: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c829: 58 pop %eax <== NOT EXECUTED 10c82a: ff 35 5c 1a 12 00 pushl 0x121a5c <== NOT EXECUTED 10c830: e8 cf e9 ff ff call 10b204 <_API_Mutex_Unlock> <== NOT EXECUTED 10c835: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10c838: 88 d8 mov %bl,%al <== NOT EXECUTED 10c83a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c83d: 5b pop %ebx <== NOT EXECUTED 10c83e: 5e pop %esi <== NOT EXECUTED 10c83f: 5f pop %edi <== NOT EXECUTED 10c840: c9 leave <== NOT EXECUTED 10c841: 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 ); 10c842: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c845: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10c848: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10c84b: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10c84e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c851: 5b pop %ebx <== NOT EXECUTED 10c852: 5e pop %esi <== NOT EXECUTED 10c853: 5f pop %edi <== NOT EXECUTED 10c854: 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 ); 10c855: e9 56 38 00 00 jmp 1100b0 <_Heap_Walk> <== NOT EXECUTED 001098b0 <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 1098b0: 55 push %ebp <== NOT EXECUTED 1098b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098b3: 53 push %ebx <== NOT EXECUTED 1098b4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 1098b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1098ba: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 1098bd: c7 05 54 d6 11 00 a4 movl $0x11dba4,0x11d654 <== NOT EXECUTED 1098c4: db 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 1098c7: e8 58 40 00 00 call 10d924 <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 1098cc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098cf: ff 33 pushl (%ebx) <== NOT EXECUTED 1098d1: e8 bd 41 00 00 call 10da93 <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 1098d6: 58 pop %eax <== NOT EXECUTED 1098d7: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1098da: e8 e9 40 00 00 call 10d9c8 <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 1098df: e8 40 41 00 00 call 10da24 <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 1098e4: e8 2b 40 00 00 call 10d914 <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 1098e9: 58 pop %eax <== NOT EXECUTED 1098ea: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1098ed: e8 3a 40 00 00 call 10d92c <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 1098f2: 58 pop %eax <== NOT EXECUTED 1098f3: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1098f6: e8 05 41 00 00 call 10da00 <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 1098fb: 58 pop %eax <== NOT EXECUTED 1098fc: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 1098ff: e8 50 40 00 00 call 10d954 <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 109904: 59 pop %ecx <== NOT EXECUTED 109905: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109908: e8 93 40 00 00 call 10d9a0 <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10990d: 5a pop %edx <== NOT EXECUTED 10990e: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 109911: e8 da 3f 00 00 call 10d8f0 <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 109916: 58 pop %eax <== NOT EXECUTED 109917: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10991a: e8 59 40 00 00 call 10d978 <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10991f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109922: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 109925: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 109928: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10992b: 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 ); 10992c: e9 9b 3f 00 00 jmp 10d8cc <_Barrier_Manager_initialization> <== NOT EXECUTED 0010dc14 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10dc14: 55 push %ebp <== NOT EXECUTED 10dc15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc17: 56 push %esi <== NOT EXECUTED 10dc18: 53 push %ebx <== NOT EXECUTED 10dc19: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10dc1c: 8b 73 10 mov 0x10(%ebx),%esi <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10dc1f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dc22: 3b 05 38 d7 11 00 cmp 0x11d738,%eax <== NOT EXECUTED 10dc28: 75 0c jne 10dc36 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x22> <== NOT EXECUTED value = *tvp->ptr; 10dc2a: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10dc2d: 8b 0a mov (%edx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; 10dc2f: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10dc32: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10dc34: eb 03 jmp 10dc39 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x25> <== NOT EXECUTED } else { value = tvp->tval; 10dc36: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED } if ( dtor ) 10dc39: 85 f6 test %esi,%esi <== NOT EXECUTED 10dc3b: 74 09 je 10dc46 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x32> <== NOT EXECUTED (*dtor)(value); 10dc3d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc40: 51 push %ecx <== NOT EXECUTED 10dc41: ff d6 call *%esi <== NOT EXECUTED 10dc43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10dc46: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10dc49: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dc4c: 5b pop %ebx <== NOT EXECUTED 10dc4d: 5e pop %esi <== NOT EXECUTED 10dc4e: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10dc4f: e9 94 e1 ff ff jmp 10bde8 <_Workspace_Free> <== NOT EXECUTED 0010db83 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10db83: 55 push %ebp <== NOT EXECUTED 10db84: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db86: 53 push %ebx <== NOT EXECUTED 10db87: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10db8a: 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() ) 10db8d: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10db92: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10db95: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10db99: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10db9b: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10db9e: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10dba1: 50 push %eax <== NOT EXECUTED 10dba2: e8 56 e2 ff ff call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10dba7: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10dba9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dbae: 85 d2 test %edx,%edx <== NOT EXECUTED 10dbb0: 74 5d je 10dc0f <_RTEMS_tasks_Create_extension+0x8c> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10dbb2: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10dbb8: 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 10dbbe: 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 10dbc2: 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. 10dbc9: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10dbd0: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10dbd7: 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 10dbde: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10dbe5: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10dbec: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10dbef: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10dbf4: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10dbf7: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10dbfb: 74 10 je 10dc0d <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10dbfd: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10dbff: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10dc06: 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++) 10dc07: 40 inc %eax <== NOT EXECUTED 10dc08: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10dc0b: 75 f2 jne 10dbff <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10dc0d: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10dc0f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dc12: c9 leave <== NOT EXECUTED 10dc13: c3 ret <== NOT EXECUTED 0010db33 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10db33: 55 push %ebp <== NOT EXECUTED 10db34: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db36: 56 push %esi <== NOT EXECUTED 10db37: 53 push %ebx <== NOT EXECUTED 10db38: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10db3b: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10db41: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10db48: 00 00 00 <== NOT EXECUTED 10db4b: eb 10 jmp 10db5d <_RTEMS_tasks_Delete_extension+0x2a> <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; 10db4d: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10db4f: 52 push %edx <== NOT EXECUTED 10db50: 52 push %edx <== NOT EXECUTED 10db51: 50 push %eax <== NOT EXECUTED 10db52: 56 push %esi <== NOT EXECUTED 10db53: e8 bc 00 00 00 call 10dc14 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10db58: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10db5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10db5d: 85 c0 test %eax,%eax <== NOT EXECUTED 10db5f: 75 ec jne 10db4d <_RTEMS_tasks_Delete_extension+0x1a> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10db61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10db64: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10db6a: e8 79 e2 ff ff call 10bde8 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10db6f: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10db76: 00 00 00 <== NOT EXECUTED 10db79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10db7c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10db7f: 5b pop %ebx <== NOT EXECUTED 10db80: 5e pop %esi <== NOT EXECUTED 10db81: c9 leave <== NOT EXECUTED 10db82: c3 ret <== NOT EXECUTED 0010da81 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10da81: 55 push %ebp <== NOT EXECUTED 10da82: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10da84: 8b 0d b4 92 11 00 mov 0x1192b4,%ecx <== NOT EXECUTED 10da8a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10da8c: 74 03 je 10da91 <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10da8e: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10da8f: ff e1 jmp *%ecx <== NOT EXECUTED } 10da91: c9 leave <== NOT EXECUTED 10da92: 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 10 d7 11 00 mov 0x11d710,%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 a7 0c 00 00 call 10a1c8 <_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 0010da93 <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10da93: 55 push %ebp <== NOT EXECUTED 10da94: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da96: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10da99: 6a 04 push $0x4 <== NOT EXECUTED 10da9b: 6a 00 push $0x0 <== NOT EXECUTED 10da9d: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10daa2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10daa5: 6a 01 push $0x1 <== NOT EXECUTED 10daa7: 6a 02 push $0x2 <== NOT EXECUTED 10daa9: 68 00 d6 11 00 push $0x11d600 <== NOT EXECUTED 10daae: e8 45 cc ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10dab3: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10dab6: 68 ac b5 11 00 push $0x11b5ac <== NOT EXECUTED 10dabb: e8 14 0a 00 00 call 10e4d4 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10dac0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dac3: c7 45 08 98 b5 11 00 movl $0x11b598,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10daca: 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 ); 10dacb: e9 06 bf ff ff jmp 1099d6 <_API_extensions_Add> <== NOT EXECUTED 0010dad0 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10dad0: 55 push %ebp <== NOT EXECUTED 10dad1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dad3: 57 push %edi <== NOT EXECUTED 10dad4: 56 push %esi <== NOT EXECUTED 10dad5: 53 push %ebx <== NOT EXECUTED 10dad6: 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 ]; 10dad9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dadc: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10dae2: 85 f6 test %esi,%esi <== NOT EXECUTED 10dae4: 74 45 je 10db2b <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10dae6: 9c pushf <== NOT EXECUTED 10dae7: fa cli <== NOT EXECUTED 10dae8: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10dae9: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10daec: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10daf3: 50 push %eax <== NOT EXECUTED 10daf4: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10daf5: 85 ff test %edi,%edi <== NOT EXECUTED 10daf7: 74 32 je 10db2b <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10daf9: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10dafc: 50 push %eax <== NOT EXECUTED 10dafd: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10db00: 53 push %ebx <== NOT EXECUTED 10db01: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10db06: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10db09: e8 56 11 00 00 call 10ec64 <== NOT EXECUTED (*asr->handler)( signal_set ); 10db0e: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10db11: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10db14: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10db17: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10db1a: 53 push %ebx <== NOT EXECUTED 10db1b: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10db20: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10db23: e8 3c 11 00 00 call 10ec64 <== NOT EXECUTED 10db28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10db2b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db2e: 5b pop %ebx <== NOT EXECUTED 10db2f: 5e pop %esi <== NOT EXECUTED 10db30: 5f pop %edi <== NOT EXECUTED 10db31: c9 leave <== NOT EXECUTED 10db32: c3 ret <== NOT EXECUTED 0010da2c <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10da2c: 55 push %ebp <== NOT EXECUTED 10da2d: 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; 10da2f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10da32: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10da38: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10da3e: c9 leave <== NOT EXECUTED 10da3f: c3 ret <== NOT EXECUTED 0010da40 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10da40: 55 push %ebp <== NOT EXECUTED 10da41: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10da43: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10da46: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10da4c: eb 0f jmp 10da5d <_RTEMS_tasks_Switch_extension+0x1d> <== NOT EXECUTED while (tvp) { tvp->tval = *tvp->ptr; 10da4e: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10da51: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10da53: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10da56: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10da59: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10da5b: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10da5d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10da5f: 75 ed jne 10da4e <_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; 10da61: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10da64: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10da6a: eb 0f jmp 10da7b <_RTEMS_tasks_Switch_extension+0x3b> <== NOT EXECUTED while (tvp) { tvp->gval = *tvp->ptr; 10da6c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10da6f: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10da71: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10da74: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10da77: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10da79: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10da7b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10da7d: 75 ed jne 10da6c <_RTEMS_tasks_Switch_extension+0x2c> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10da7f: c9 leave <== NOT EXECUTED 10da80: 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 6c 17 00 00 call 10b530 <_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 bc 1b 12 00 cmp 0x121bbc,%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 c4 1b 12 00 push $0x121bc4 <== NOT EXECUTED 109df8: e8 73 34 00 00 call 10d270 <_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 73 33 00 00 call 10d17c <_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 0010d978 <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10d978: 55 push %ebp <== NOT EXECUTED 10d979: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d97b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d97e: 6a 04 push $0x4 <== NOT EXECUTED 10d980: 6a 00 push $0x0 <== NOT EXECUTED 10d982: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10d987: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d98a: 6a 08 push $0x8 <== NOT EXECUTED 10d98c: 6a 02 push $0x2 <== NOT EXECUTED 10d98e: 68 b8 e0 11 00 push $0x11e0b8 <== NOT EXECUTED 10d993: e8 60 cd ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d998: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d99b: c9 leave <== NOT EXECUTED 10d99c: 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 04 1a 12 00 push $0x121a04 <== NOT EXECUTED 10a2fb: e8 98 1a 00 00 call 10bd98 <_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 af 1e 00 00 call 10c1d8 <_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 dc 1b 12 00 push $0x121bdc <== NOT EXECUTED 10a353: e8 5c 31 00 00 call 10d4b4 <_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 fc 1a 12 00 mov 0x121afc,%eax <== NOT EXECUTED 10a369: 48 dec %eax <== NOT EXECUTED 10a36a: a3 fc 1a 12 00 mov %eax,0x121afc <== 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 07 17 00 00 call 10b530 <_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 26 34 00 00 call 10d270 <_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 bc 1b 12 00 mov 0x121bbc,%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 c4 1b 12 00 push $0x121bc4 <== NOT EXECUTED 109e6e: e8 fd 33 00 00 call 10d270 <_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 fd 32 00 00 call 10d17c <_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 ba 33 00 00 call 10d248 <_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 c9 33 00 00 call 10d270 <_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 c9 32 00 00 call 10d17c <_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 89 33 00 00 call 10d248 <_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 3f 33 00 00 call 10d220 <_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 76 32 00 00 call 10d17c <_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 36 33 00 00 call 10d248 <_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 ec 32 00 00 call 10d220 <_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 0010d9a0 <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10d9a0: 55 push %ebp <== NOT EXECUTED 10d9a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d9a3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d9a6: 6a 04 push $0x4 <== NOT EXECUTED 10d9a8: 6a 00 push $0x0 <== NOT EXECUTED 10d9aa: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10d9af: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9b2: 6a 06 push $0x6 <== NOT EXECUTED 10d9b4: 6a 02 push $0x2 <== NOT EXECUTED 10d9b6: 68 f8 e0 11 00 push $0x11e0f8 <== NOT EXECUTED 10d9bb: e8 38 cd ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10d9c0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10d9c3: c9 leave <== NOT EXECUTED 10d9c4: c3 ret <== NOT EXECUTED 00118704 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 118704: 55 push %ebp <== NOT EXECUTED 118705: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118707: 57 push %edi <== NOT EXECUTED 118708: 56 push %esi <== NOT EXECUTED 118709: 53 push %ebx <== NOT EXECUTED 11870a: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 11870d: 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 118710: a1 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 118715: 40 inc %eax <== NOT EXECUTED 118716: a3 38 40 13 00 mov %eax,0x134038 <== 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(); 11871b: ff 35 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 118721: e8 06 b3 ff ff call 113a2c <_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 ); 118726: 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. * 118729: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 11872c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11872f: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 118732: e8 dd 06 00 00 call 118e14 <_Thread_queue_First> <== NOT EXECUTED 118737: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 118739: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11873c: 85 c0 test %eax,%eax <== NOT EXECUTED 11873e: 74 30 je 118770 <_Region_Process_queue+0x6c> <== NOT EXECUTED 118740: 52 push %edx <== NOT EXECUTED 118741: 52 push %edx <== NOT EXECUTED 118742: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 118745: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 118748: e8 27 bc ff ff call 114374 <_Heap_Allocate> <== NOT EXECUTED 11874d: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11874f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118752: 85 c0 test %eax,%eax <== NOT EXECUTED 118754: 74 1a je 118770 <_Region_Process_queue+0x6c> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 118756: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 118759: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 11875b: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11875e: 50 push %eax <== NOT EXECUTED 11875f: 50 push %eax <== NOT EXECUTED 118760: 53 push %ebx <== NOT EXECUTED 118761: 57 push %edi <== NOT EXECUTED 118762: e8 bd 05 00 00 call 118d24 <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 118767: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 11876e: eb bf jmp 11872f <_Region_Process_queue+0x2b> <== NOT EXECUTED } _Thread_Enable_dispatch(); } 118770: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118773: 5b pop %ebx <== NOT EXECUTED 118774: 5e pop %esi <== NOT EXECUTED 118775: 5f pop %edi <== NOT EXECUTED 118776: 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(); 118777: e9 10 d0 ff ff jmp 11578c <_Thread_Enable_dispatch> <== NOT EXECUTED 0010da00 <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10da00: 55 push %ebp <== NOT EXECUTED 10da01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da03: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10da06: 6a 04 push $0x4 <== NOT EXECUTED 10da08: 6a 00 push $0x0 <== NOT EXECUTED 10da0a: 6a 78 push $0x78 <== NOT EXECUTED 10da0c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10da0f: 6a 03 push $0x3 <== NOT EXECUTED 10da11: 6a 02 push $0x2 <== NOT EXECUTED 10da13: 68 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 10da18: e8 db cc ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10da1d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10da20: c9 leave <== NOT EXECUTED 10da21: 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 71 11 00 mov 0x1171b8(,%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 71 11 00 mov 0x1171d4(,%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 0010da24 <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10da24: 55 push %ebp <== NOT EXECUTED 10da25: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10da27: c9 leave <== NOT EXECUTED 10da28: c3 ret <== NOT EXECUTED 00109f10 <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 109f10: 55 push %ebp <== NOT EXECUTED 109f11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f13: 56 push %esi <== NOT EXECUTED 109f14: 53 push %ebx <== NOT EXECUTED 109f15: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109f18: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 109f1b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 109f22: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 109f29: 9c pushf <== NOT EXECUTED 109f2a: fa cli <== NOT EXECUTED 109f2b: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 109f2c: a1 08 d7 11 00 mov 0x11d708,%eax <== NOT EXECUTED 109f31: 8b 15 0c d7 11 00 mov 0x11d70c,%edx <== NOT EXECUTED 109f37: 89 06 mov %eax,(%esi) <== NOT EXECUTED 109f39: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 109f3c: a1 1c d8 11 00 mov 0x11d81c,%eax <== NOT EXECUTED 109f41: 85 c0 test %eax,%eax <== NOT EXECUTED 109f43: 74 05 je 109f4a <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 109f45: ff d0 call *%eax <== NOT EXECUTED 109f47: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 109f4a: 53 push %ebx <== NOT EXECUTED 109f4b: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 109f4c: 50 push %eax <== NOT EXECUTED 109f4d: 50 push %eax <== NOT EXECUTED 109f4e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109f51: 50 push %eax <== NOT EXECUTED 109f52: 56 push %esi <== NOT EXECUTED 109f53: e8 30 1a 00 00 call 10b988 <_Timespec_Add_to> <== NOT EXECUTED 109f58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109f5b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109f5e: 5b pop %ebx <== NOT EXECUTED 109f5f: 5e pop %esi <== NOT EXECUTED 109f60: c9 leave <== NOT EXECUTED 109f61: c3 ret <== NOT EXECUTED 0010decc <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10decc: 55 push %ebp <== NOT EXECUTED 10decd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10decf: 56 push %esi <== NOT EXECUTED 10ded0: 53 push %ebx <== NOT EXECUTED 10ded1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ded4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10ded7: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10dede: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10dee5: 9c pushf <== NOT EXECUTED 10dee6: fa cli <== NOT EXECUTED 10dee7: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10dee8: a1 f4 d6 11 00 mov 0x11d6f4,%eax <== NOT EXECUTED 10deed: 8b 15 f8 d6 11 00 mov 0x11d6f8,%edx <== NOT EXECUTED 10def3: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10def5: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10def8: a1 1c d8 11 00 mov 0x11d81c,%eax <== NOT EXECUTED 10defd: 85 c0 test %eax,%eax <== NOT EXECUTED 10deff: 74 05 je 10df06 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10df01: ff d0 call *%eax <== NOT EXECUTED 10df03: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10df06: 53 push %ebx <== NOT EXECUTED 10df07: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10df08: 50 push %eax <== NOT EXECUTED 10df09: 50 push %eax <== NOT EXECUTED 10df0a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10df0d: 50 push %eax <== NOT EXECUTED 10df0e: 56 push %esi <== NOT EXECUTED 10df0f: e8 74 da ff ff call 10b988 <_Timespec_Add_to> <== NOT EXECUTED 10df14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10df17: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10df1a: 5b pop %ebx <== NOT EXECUTED 10df1b: 5e pop %esi <== NOT EXECUTED 10df1c: c9 leave <== NOT EXECUTED 10df1d: c3 ret <== NOT EXECUTED 00109f64 <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 109f64: 55 push %ebp <== NOT EXECUTED 109f65: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 109f67: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109f6a: a3 14 d8 11 00 mov %eax,0x11d814 <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 109f6f: c7 05 08 d7 11 00 00 movl $0x21dae500,0x11d708 <== NOT EXECUTED 109f76: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 109f79: c7 05 0c d7 11 00 00 movl $0x0,0x11d70c <== NOT EXECUTED 109f80: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 109f83: c7 05 f4 d6 11 00 00 movl $0x0,0x11d6f4 <== NOT EXECUTED 109f8a: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 109f8d: c7 05 f8 d6 11 00 00 movl $0x0,0x11d6f8 <== NOT EXECUTED 109f94: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 109f97: c6 05 8c d6 11 00 00 movb $0x0,0x11d68c <== NOT EXECUTED _TOD_Activate(); } 109f9e: c9 leave <== NOT EXECUTED 109f9f: c3 ret <== NOT EXECUTED 0010b194 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10b194: 55 push %ebp <== NOT EXECUTED 10b195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b197: 53 push %ebx <== NOT EXECUTED 10b198: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b19b: 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 10b19e: a1 14 94 12 00 mov 0x129414,%eax <== NOT EXECUTED 10b1a3: 40 inc %eax <== NOT EXECUTED 10b1a4: a3 14 94 12 00 mov %eax,0x129414 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10b1a9: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b1ab: a1 a4 94 12 00 mov 0x1294a4,%eax <== NOT EXECUTED 10b1b0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b1b2: 7d 08 jge 10b1bc <_TOD_Set+0x28> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10b1b4: 51 push %ecx <== NOT EXECUTED 10b1b5: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b1b7: 50 push %eax <== NOT EXECUTED 10b1b8: 6a 01 push $0x1 <== NOT EXECUTED 10b1ba: eb 06 jmp 10b1c2 <_TOD_Set+0x2e> <== NOT EXECUTED 10b1bc: 51 push %ecx <== NOT EXECUTED 10b1bd: 29 c2 sub %eax,%edx <== NOT EXECUTED 10b1bf: 52 push %edx <== NOT EXECUTED 10b1c0: 6a 00 push $0x0 <== NOT EXECUTED 10b1c2: 68 e8 94 12 00 push $0x1294e8 <== NOT EXECUTED 10b1c7: e8 68 20 00 00 call 10d234 <_Watchdog_Adjust> <== NOT EXECUTED 10b1cc: 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; 10b1cf: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b1d1: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b1d4: a3 a8 94 12 00 mov %eax,0x1294a8 <== NOT EXECUTED 10b1d9: 89 15 a4 94 12 00 mov %edx,0x1294a4 <== NOT EXECUTED _TOD_Is_set = TRUE; 10b1df: c6 05 28 94 12 00 01 movb $0x1,0x129428 <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10b1e6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1e9: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10b1ea: e9 f1 0f 00 00 jmp 10c1e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 00109fa0 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 109fa0: 55 push %ebp <== NOT EXECUTED 109fa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109fa3: 53 push %ebx <== NOT EXECUTED 109fa4: 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; 109fa7: 69 05 14 d8 11 00 e8 imul $0x3e8,0x11d814,%eax <== NOT EXECUTED 109fae: 03 00 00 <== NOT EXECUTED 109fb1: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 109fb4: 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; 109fbb: a1 c8 d7 11 00 mov 0x11d7c8,%eax <== NOT EXECUTED 109fc0: 40 inc %eax <== NOT EXECUTED 109fc1: a3 c8 d7 11 00 mov %eax,0x11d7c8 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 109fc6: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 109fc9: 53 push %ebx <== NOT EXECUTED 109fca: 68 f4 d6 11 00 push $0x11d6f4 <== NOT EXECUTED 109fcf: e8 b4 19 00 00 call 10b988 <_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 ); 109fd4: 58 pop %eax <== NOT EXECUTED 109fd5: 5a pop %edx <== NOT EXECUTED 109fd6: 53 push %ebx <== NOT EXECUTED 109fd7: 68 08 d7 11 00 push $0x11d708 <== NOT EXECUTED 109fdc: e8 a7 19 00 00 call 10b988 <_Timespec_Add_to> <== NOT EXECUTED 109fe1: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109fe3: eb 0e jmp 109ff3 <_TOD_Tickle_ticks+0x53> <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 109fe5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fe8: 68 4c d7 11 00 push $0x11d74c <== NOT EXECUTED 109fed: e8 8a 1d 00 00 call 10bd7c <_Watchdog_Tickle> <== NOT EXECUTED while ( seconds ) { _Watchdog_Tickle_seconds(); seconds--; 109ff2: 4b dec %ebx <== NOT EXECUTED 109ff3: 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 ) { 109ff6: 85 db test %ebx,%ebx <== NOT EXECUTED 109ff8: 75 eb jne 109fe5 <_TOD_Tickle_ticks+0x45> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 109ffa: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ffd: c9 leave <== NOT EXECUTED 109ffe: 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 a6 11 movzwl 0x11a65a(%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 a6 11 movzwl 0x11a640(%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 a6 11 movzwl 0x11a674(%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 b0 95 12 00 divl 0x1295b0 <== 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 a6 11 00 mov 0x11a6b0(,%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 a6 11 00 mov 0x11a67c(,%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 0010a9c0 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10a9c0: 55 push %ebp <== NOT EXECUTED 10a9c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a9c3: 57 push %edi <== NOT EXECUTED 10a9c4: 56 push %esi <== NOT EXECUTED 10a9c5: 53 push %ebx <== NOT EXECUTED 10a9c6: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a9c9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a9cc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a9cf: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10a9d2: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10a9d5: 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 ); 10a9d8: 53 push %ebx <== NOT EXECUTED 10a9d9: e8 3e 0d 00 00 call 10b71c <_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 ) 10a9de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9e1: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10a9e4: 74 0c je 10a9f2 <_Thread_Change_priority+0x32> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10a9e6: 50 push %eax <== NOT EXECUTED 10a9e7: 50 push %eax <== NOT EXECUTED 10a9e8: 56 push %esi <== NOT EXECUTED 10a9e9: 53 push %ebx <== NOT EXECUTED 10a9ea: e8 f9 0b 00 00 call 10b5e8 <_Thread_Set_priority> <== NOT EXECUTED 10a9ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10a9f2: 9c pushf <== NOT EXECUTED 10a9f3: fa cli <== NOT EXECUTED 10a9f4: 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; 10a9f5: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10a9f8: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10a9fb: 74 30 je 10aa2d <_Thread_Change_priority+0x6d> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10a9fd: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10aa00: 75 08 jne 10aa0a <_Thread_Change_priority+0x4a> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10aa02: 89 d0 mov %edx,%eax <== NOT EXECUTED 10aa04: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10aa07: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10aa0a: 56 push %esi <== NOT EXECUTED 10aa0b: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10aa0c: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10aa12: 0f 84 c0 00 00 00 je 10aad8 <_Thread_Change_priority+0x118> <== NOT EXECUTED _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10aa18: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10aa1b: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10aa1e: 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 ); } 10aa21: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa24: 5b pop %ebx <== NOT EXECUTED 10aa25: 5e pop %esi <== NOT EXECUTED 10aa26: 5f pop %edi <== NOT EXECUTED 10aa27: 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 ); 10aa28: e9 33 0b 00 00 jmp 10b560 <_Thread_queue_Requeue> <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10aa2d: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10aa30: 75 53 jne 10aa85 <_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 ); 10aa32: 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 10aa39: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10aa3f: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10aa46: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10aa49: 66 a1 2c d7 11 00 mov 0x11d72c,%ax <== NOT EXECUTED 10aa4f: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10aa55: 66 a3 2c d7 11 00 mov %ax,0x11d72c <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10aa5b: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10aa5f: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED 10aa65: 74 0e je 10aa75 <_Thread_Change_priority+0xb5> <== NOT EXECUTED 10aa67: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10aa6a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10aa6c: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10aa6e: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10aa70: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 10aa73: eb 10 jmp 10aa85 <_Thread_Change_priority+0xc5> <== NOT EXECUTED 10aa75: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10aa78: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10aa7a: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10aa7d: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10aa80: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10aa82: 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 ); 10aa85: 56 push %esi <== NOT EXECUTED 10aa86: 9d popf <== NOT EXECUTED 10aa87: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10aa88: 66 8b 0d 2c d7 11 00 mov 0x11d72c,%cx <== NOT EXECUTED 10aa8f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aa91: 89 d0 mov %edx,%eax <== NOT EXECUTED 10aa93: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10aa97: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10aa9a: 66 8b 8c 00 a4 d7 11 mov 0x11d7a4(%eax,%eax,1),%cx <== NOT EXECUTED 10aaa1: 00 <== NOT EXECUTED 10aaa2: 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. 10aaa6: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10aaa9: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10aaac: 01 d0 add %edx,%eax <== NOT EXECUTED 10aaae: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10aab1: 8b 15 40 d6 11 00 mov 0x11d640,%edx <== NOT EXECUTED 10aab7: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10aaba: a3 04 d7 11 00 mov %eax,0x11d704 <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10aabf: 8b 15 38 d7 11 00 mov 0x11d738,%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() && 10aac5: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aac7: 74 0d je 10aad6 <_Thread_Change_priority+0x116> <== NOT EXECUTED 10aac9: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10aacd: 74 07 je 10aad6 <_Thread_Change_priority+0x116> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10aacf: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED _ISR_Enable( level ); 10aad6: 56 push %esi <== NOT EXECUTED 10aad7: 9d popf <== NOT EXECUTED } 10aad8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aadb: 5b pop %ebx <== NOT EXECUTED 10aadc: 5e pop %esi <== NOT EXECUTED 10aadd: 5f pop %edi <== NOT EXECUTED 10aade: c9 leave <== NOT EXECUTED 10aadf: c3 ret <== NOT EXECUTED 0010aae0 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10aae0: 55 push %ebp <== NOT EXECUTED 10aae1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aae3: 53 push %ebx <== NOT EXECUTED 10aae4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aae7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10aaea: 9c pushf <== NOT EXECUTED 10aaeb: fa cli <== NOT EXECUTED 10aaec: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10aaed: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10aaf0: 85 d0 test %edx,%eax <== NOT EXECUTED 10aaf2: 74 6f je 10ab63 <_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( 10aaf4: f7 d0 not %eax <== NOT EXECUTED 10aaf6: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10aaf8: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10aafb: 85 c0 test %eax,%eax <== NOT EXECUTED 10aafd: 75 64 jne 10ab63 <_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 10aaff: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10ab05: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10ab0c: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10ab0f: 66 a1 2c d7 11 00 mov 0x11d72c,%ax <== NOT EXECUTED 10ab15: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10ab1b: 66 a3 2c d7 11 00 mov %ax,0x11d72c <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10ab21: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10ab27: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10ab2a: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10ab2c: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10ab2f: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10ab32: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10ab34: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10ab37: 53 push %ebx <== NOT EXECUTED 10ab38: 9d popf <== NOT EXECUTED 10ab39: 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 ) { 10ab3a: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10ab3d: a1 04 d7 11 00 mov 0x11d704,%eax <== NOT EXECUTED 10ab42: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10ab45: 73 1c jae 10ab63 <_Thread_Clear_state+0x83> <== NOT EXECUTED _Thread_Heir = the_thread; 10ab47: 89 0d 04 d7 11 00 mov %ecx,0x11d704 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10ab4d: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED 10ab52: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10ab56: 75 04 jne 10ab5c <_Thread_Clear_state+0x7c> <== NOT EXECUTED 10ab58: 85 d2 test %edx,%edx <== NOT EXECUTED 10ab5a: 75 07 jne 10ab63 <_Thread_Clear_state+0x83> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10ab5c: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED } } } _ISR_Enable( level ); 10ab63: 53 push %ebx <== NOT EXECUTED 10ab64: 9d popf <== NOT EXECUTED } 10ab65: 5b pop %ebx <== NOT EXECUTED 10ab66: c9 leave <== NOT EXECUTED 10ab67: c3 ret <== NOT EXECUTED 0010ab68 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10ab68: 55 push %ebp <== NOT EXECUTED 10ab69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab6b: 56 push %esi <== NOT EXECUTED 10ab6c: 53 push %ebx <== NOT EXECUTED 10ab6d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ab70: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ab73: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10ab77: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10ab7a: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10ab81: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ab86: 48 dec %eax <== NOT EXECUTED 10ab87: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10ab8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab8f: 56 push %esi <== NOT EXECUTED 10ab90: e8 c3 0f 00 00 call 10bb58 <_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 10ab95: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ab9a: 40 inc %eax <== NOT EXECUTED 10ab9b: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 ); 10aba0: 59 pop %ecx <== NOT EXECUTED 10aba1: 58 pop %eax <== NOT EXECUTED 10aba2: 56 push %esi <== NOT EXECUTED 10aba3: 53 push %ebx <== NOT EXECUTED 10aba4: e8 27 f7 ff ff call 10a2d0 <_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 ); 10aba9: 58 pop %eax <== NOT EXECUTED 10abaa: 5a pop %edx <== NOT EXECUTED 10abab: 6a 01 push $0x1 <== NOT EXECUTED 10abad: 56 push %esi <== NOT EXECUTED 10abae: e8 9d 0a 00 00 call 10b650 <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10abb3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10abb6: e8 d9 08 00 00 call 10b494 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10abbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abbe: 84 c0 test %al,%al <== NOT EXECUTED 10abc0: 75 15 jne 10abd7 <_Thread_Close+0x6f> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10abc2: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10abc6: 75 0f jne 10abd7 <_Thread_Close+0x6f> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10abc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abcb: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10abce: 50 push %eax <== NOT EXECUTED 10abcf: e8 40 11 00 00 call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED 10abd4: 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 ) ) 10abd7: 3b 35 fc d6 11 00 cmp 0x11d6fc,%esi <== NOT EXECUTED 10abdd: 75 0a jne 10abe9 <_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( 10abdf: c7 05 fc d6 11 00 00 movl $0x0,0x11d6fc <== NOT EXECUTED 10abe6: 00 00 00 <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10abe9: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10abf0: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10abf3: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10abf9: 85 c0 test %eax,%eax <== NOT EXECUTED 10abfb: 74 0c je 10ac09 <_Thread_Close+0xa1> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10abfd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac00: 50 push %eax <== NOT EXECUTED 10ac01: e8 e2 11 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10ac06: 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 ); 10ac09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac0c: 56 push %esi <== NOT EXECUTED 10ac0d: e8 ca 0b 00 00 call 10b7dc <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10ac12: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10ac19: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10ac1c: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10ac22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac25: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac27: 74 0c je 10ac35 <_Thread_Close+0xcd> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10ac29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac2c: 50 push %eax <== NOT EXECUTED 10ac2d: e8 b6 11 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10ac32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10ac35: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10ac3c: 00 00 00 <== NOT EXECUTED } 10ac3f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ac42: 5b pop %ebx <== NOT EXECUTED 10ac43: 5e pop %esi <== NOT EXECUTED 10ac44: c9 leave <== NOT EXECUTED 10ac45: c3 ret <== NOT EXECUTED 0010ac48 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10ac48: 55 push %ebp <== NOT EXECUTED 10ac49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac4b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ac4e: 68 d4 d7 11 00 push $0x11d7d4 <== NOT EXECUTED 10ac53: e8 04 f6 ff ff call 10a25c <_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(); 10ac58: a3 20 d8 11 00 mov %eax,0x11d820 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ac5d: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ac62: 40 inc %eax <== NOT EXECUTED 10ac63: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10ac68: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10ac6d: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10ac70: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac73: 68 8c 72 11 00 push $0x11728c <== NOT EXECUTED 10ac78: 6a 00 push $0x0 <== NOT EXECUTED 10ac7a: 6a 00 push $0x0 <== NOT EXECUTED 10ac7c: 6a 00 push $0x0 <== NOT EXECUTED 10ac7e: 6a 01 push $0x1 <== NOT EXECUTED 10ac80: 0f b6 05 64 92 11 00 movzbl 0x119264,%eax <== NOT EXECUTED 10ac87: 50 push %eax <== NOT EXECUTED 10ac88: 6a 00 push $0x0 <== NOT EXECUTED 10ac8a: a1 60 92 11 00 mov 0x119260,%eax <== NOT EXECUTED 10ac8f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10ac91: 73 02 jae 10ac95 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10ac93: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ac95: 50 push %eax <== NOT EXECUTED 10ac96: 6a 00 push $0x0 <== NOT EXECUTED 10ac98: ff 35 20 d8 11 00 pushl 0x11d820 <== NOT EXECUTED 10ac9e: 68 d4 d7 11 00 push $0x11d7d4 <== NOT EXECUTED 10aca3: e8 50 02 00 00 call 10aef8 <_Thread_Initialize> <== NOT EXECUTED 10aca8: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10acad: 48 dec %eax <== NOT EXECUTED 10acae: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10acb3: 8b 15 20 d8 11 00 mov 0x11d820,%edx <== NOT EXECUTED 10acb9: 89 15 38 d7 11 00 mov %edx,0x11d738 <== NOT EXECUTED 10acbf: 89 15 04 d7 11 00 mov %edx,0x11d704 <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10acc5: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10acc8: 6a 00 push $0x0 <== NOT EXECUTED 10acca: 6a 00 push $0x0 <== NOT EXECUTED 10accc: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10acd1: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10acd4: 6a 00 push $0x0 <== NOT EXECUTED 10acd6: 52 push %edx <== NOT EXECUTED 10acd7: e8 8c 0b 00 00 call 10b868 <_Thread_Start> <== NOT EXECUTED 10acdc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10acdf: c9 leave <== NOT EXECUTED 10ace0: c3 ret <== NOT EXECUTED 0010ace4 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10ace4: 55 push %ebp <== NOT EXECUTED 10ace5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ace7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10acea: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10aced: 50 push %eax <== NOT EXECUTED 10acee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acf1: e8 8a 01 00 00 call 10ae80 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10acf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10acf9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10acfd: 75 1b jne 10ad1a <_Thread_Delay_ended+0x36> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10acff: 52 push %edx <== NOT EXECUTED 10ad00: 52 push %edx <== NOT EXECUTED 10ad01: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10ad06: 50 push %eax <== NOT EXECUTED 10ad07: e8 d4 fd ff ff call 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 10ad0c: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ad11: 48 dec %eax <== NOT EXECUTED 10ad12: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED 10ad17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10ad1a: c9 leave <== NOT EXECUTED 10ad1b: c3 ret <== NOT EXECUTED 0010ad1c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10ad1c: 55 push %ebp <== NOT EXECUTED 10ad1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad1f: 57 push %edi <== NOT EXECUTED 10ad20: 56 push %esi <== NOT EXECUTED 10ad21: 53 push %ebx <== NOT EXECUTED 10ad22: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10ad25: 8b 1d 38 d7 11 00 mov 0x11d738,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ad2b: 9c pushf <== NOT EXECUTED 10ad2c: fa cli <== NOT EXECUTED 10ad2d: 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); 10ad2e: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ad31: e9 f1 00 00 00 jmp 10ae27 <_Thread_Dispatch+0x10b> <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; 10ad36: 8b 35 04 d7 11 00 mov 0x11d704,%esi <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10ad3c: c7 05 78 d6 11 00 01 movl $0x1,0x11d678 <== NOT EXECUTED 10ad43: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10ad46: c6 05 48 d7 11 00 00 movb $0x0,0x11d748 <== NOT EXECUTED _Thread_Executing = heir; 10ad4d: 89 35 38 d7 11 00 mov %esi,0x11d738 <== 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 ) 10ad53: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) <== NOT EXECUTED 10ad57: 75 08 jne 10ad61 <_Thread_Dispatch+0x45> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ad59: a1 44 d6 11 00 mov 0x11d644,%eax <== NOT EXECUTED 10ad5e: 89 46 78 mov %eax,0x78(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10ad61: 52 push %edx <== NOT EXECUTED 10ad62: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10ad63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad66: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad69: 50 push %eax <== NOT EXECUTED 10ad6a: e8 5d 31 00 00 call 10decc <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10ad6f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad72: 57 push %edi <== NOT EXECUTED 10ad73: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad76: 50 push %eax <== NOT EXECUTED 10ad77: 68 40 d7 11 00 push $0x11d740 <== NOT EXECUTED 10ad7c: e8 37 0c 00 00 call 10b9b8 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10ad81: 58 pop %eax <== NOT EXECUTED 10ad82: 5a pop %edx <== NOT EXECUTED 10ad83: 57 push %edi <== NOT EXECUTED 10ad84: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax <== NOT EXECUTED 10ad8a: 50 push %eax <== NOT EXECUTED 10ad8b: e8 f8 0b 00 00 call 10b988 <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10ad90: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ad93: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10ad96: a3 40 d7 11 00 mov %eax,0x11d740 <== NOT EXECUTED 10ad9b: 89 15 44 d7 11 00 mov %edx,0x11d744 <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10ada1: 8b 15 00 d7 11 00 mov 0x11d700,%edx <== NOT EXECUTED 10ada7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adaa: 85 d2 test %edx,%edx <== NOT EXECUTED 10adac: 74 10 je 10adbe <_Thread_Dispatch+0xa2> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10adae: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10adb0: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10adb6: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax <== NOT EXECUTED 10adbc: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10adbe: 51 push %ecx <== NOT EXECUTED 10adbf: 51 push %ecx <== NOT EXECUTED 10adc0: 56 push %esi <== NOT EXECUTED 10adc1: 53 push %ebx <== NOT EXECUTED 10adc2: e8 01 0e 00 00 call 10bbc8 <_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 ); 10adc7: 58 pop %eax <== NOT EXECUTED 10adc8: 5a pop %edx <== NOT EXECUTED 10adc9: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10adcf: 50 push %eax <== NOT EXECUTED 10add0: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10add6: 50 push %eax <== NOT EXECUTED 10add7: e8 b4 10 00 00 call 10be90 <_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) && 10addc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10addf: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10ade6: 74 36 je 10ae1e <_Thread_Dispatch+0x102> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ade8: a1 fc d6 11 00 mov 0x11d6fc,%eax <== NOT EXECUTED 10aded: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10adef: 74 2d je 10ae1e <_Thread_Dispatch+0x102> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10adf1: 85 c0 test %eax,%eax <== NOT EXECUTED 10adf3: 74 11 je 10ae06 <_Thread_Dispatch+0xea> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10adf5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adf8: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10adfd: 50 push %eax <== NOT EXECUTED 10adfe: e8 c1 10 00 00 call 10bec4 <_CPU_Context_save_fp> <== NOT EXECUTED 10ae03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10ae06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae09: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10ae0f: 50 push %eax <== NOT EXECUTED 10ae10: e8 b9 10 00 00 call 10bece <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ae15: 89 1d fc d6 11 00 mov %ebx,0x11d6fc <== NOT EXECUTED 10ae1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10ae1e: 8b 1d 38 d7 11 00 mov 0x11d738,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ae24: 9c pushf <== NOT EXECUTED 10ae25: fa cli <== NOT EXECUTED 10ae26: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10ae27: a0 48 d7 11 00 mov 0x11d748,%al <== NOT EXECUTED 10ae2c: 84 c0 test %al,%al <== NOT EXECUTED 10ae2e: 0f 85 02 ff ff ff jne 10ad36 <_Thread_Dispatch+0x1a> <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10ae34: c7 05 78 d6 11 00 00 movl $0x0,0x11d678 <== NOT EXECUTED 10ae3b: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10ae3e: 52 push %edx <== NOT EXECUTED 10ae3f: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10ae40: 83 3d 1c d7 11 00 00 cmpl $0x0,0x11d71c <== NOT EXECUTED 10ae47: 75 06 jne 10ae4f <_Thread_Dispatch+0x133> <== NOT EXECUTED 10ae49: 80 7b 75 00 cmpb $0x0,0x75(%ebx) <== NOT EXECUTED 10ae4d: 74 09 je 10ae58 <_Thread_Dispatch+0x13c> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10ae4f: c6 43 75 00 movb $0x0,0x75(%ebx) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10ae53: e8 4b eb ff ff call 1099a3 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10ae58: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae5b: 5b pop %ebx <== NOT EXECUTED 10ae5c: 5e pop %esi <== NOT EXECUTED 10ae5d: 5f pop %edi <== NOT EXECUTED 10ae5e: c9 leave <== NOT EXECUTED 10ae5f: c3 ret <== NOT EXECUTED 0010ae60 <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10ae60: 55 push %ebp <== NOT EXECUTED 10ae61: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10ae63: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ae68: 48 dec %eax <== NOT EXECUTED 10ae69: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED 10ae6e: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ae73: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae75: 75 06 jne 10ae7d <_Thread_Enable_dispatch+0x1d> <== NOT EXECUTED return; _Thread_Dispatch(); } 10ae77: 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(); 10ae78: e9 9f fe ff ff jmp 10ad1c <_Thread_Dispatch> <== NOT EXECUTED } 10ae7d: c9 leave <== NOT EXECUTED 10ae7e: c3 ret <== NOT EXECUTED 0010eecc <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10eecc: 55 push %ebp <== NOT EXECUTED 10eecd: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10eecf: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 10eed4: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10eed8: 75 0e jne 10eee8 <_Thread_Evaluate_mode+0x1c> <== NOT EXECUTED 10eeda: 3b 05 04 d7 11 00 cmp 0x11d704,%eax <== NOT EXECUTED 10eee0: 74 11 je 10eef3 <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED 10eee2: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10eee6: 74 0b je 10eef3 <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10eee8: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED 10eeef: b0 01 mov $0x1,%al <== NOT EXECUTED 10eef1: eb 02 jmp 10eef5 <_Thread_Evaluate_mode+0x29> <== NOT EXECUTED return TRUE; 10eef3: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 10eef5: c9 leave <== NOT EXECUTED 10eef6: c3 ret <== NOT EXECUTED 0010ae80 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10ae80: 55 push %ebp <== NOT EXECUTED 10ae81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae83: 53 push %ebx <== NOT EXECUTED 10ae84: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ae87: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ae8a: 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 ) ) { 10ae8d: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae8f: 75 18 jne 10aea9 <_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 10ae91: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10ae96: 40 inc %eax <== NOT EXECUTED 10ae97: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10ae9c: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED tp = _Thread_Executing; 10aea2: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED 10aea7: eb 40 jmp 10aee9 <_Thread_Get+0x69> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10aea9: 89 da mov %ebx,%edx <== NOT EXECUTED 10aeab: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10aeae: 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. 10aeb1: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10aeb4: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aeb7: 76 35 jbe 10aeee <_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; 10aeb9: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10aebf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aec1: eb 26 jmp 10aee9 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } api_information = _Objects_Information_table[ the_api ]; 10aec3: 8b 04 95 4c d6 11 00 mov 0x11d64c(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10aeca: 85 c0 test %eax,%eax <== NOT EXECUTED 10aecc: 74 07 je 10aed5 <_Thread_Get+0x55> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10aece: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10aed1: 85 c0 test %eax,%eax <== NOT EXECUTED 10aed3: 75 08 jne 10aedd <_Thread_Get+0x5d> <== NOT EXECUTED *location = OBJECTS_ERROR; 10aed5: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10aedb: eb 0c jmp 10aee9 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10aedd: 52 push %edx <== NOT EXECUTED 10aede: 51 push %ecx <== NOT EXECUTED 10aedf: 53 push %ebx <== NOT EXECUTED 10aee0: 50 push %eax <== NOT EXECUTED 10aee1: e8 ba f7 ff ff call 10a6a0 <_Objects_Get> <== NOT EXECUTED 10aee6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10aee9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aeec: c9 leave <== NOT EXECUTED 10aeed: c3 ret <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10aeee: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aef0: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10aef3: 48 dec %eax <== NOT EXECUTED 10aef4: 74 cd je 10aec3 <_Thread_Get+0x43> <== NOT EXECUTED 10aef6: eb c1 jmp 10aeb9 <_Thread_Get+0x39> <== NOT EXECUTED 0010eef8 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10eef8: 55 push %ebp <== NOT EXECUTED 10eef9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eefb: 53 push %ebx <== NOT EXECUTED 10eefc: 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; 10eeff: 8b 1d 38 d7 11 00 mov 0x11d738,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10ef05: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 10ef0b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ef0d: 74 03 je 10ef12 <_Thread_Handler+0x1a> <== NOT EXECUTED 10ef0f: fa cli <== NOT EXECUTED 10ef10: eb 01 jmp 10ef13 <_Thread_Handler+0x1b> <== NOT EXECUTED 10ef12: fb sti <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10ef13: a0 70 d4 11 00 mov 0x11d470,%al <== NOT EXECUTED 10ef18: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 10ef1b: c6 05 70 d4 11 00 01 movb $0x1,0x11d470 <== 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 ) ) { 10ef22: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10ef29: 74 24 je 10ef4f <_Thread_Handler+0x57> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ef2b: a1 fc d6 11 00 mov 0x11d6fc,%eax <== NOT EXECUTED 10ef30: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ef32: 74 1b je 10ef4f <_Thread_Handler+0x57> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 10ef34: 85 c0 test %eax,%eax <== NOT EXECUTED 10ef36: 74 11 je 10ef49 <_Thread_Handler+0x51> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ef38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef3b: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10ef40: 50 push %eax <== NOT EXECUTED 10ef41: e8 7e cf ff ff call 10bec4 <_CPU_Context_save_fp> <== NOT EXECUTED 10ef46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ef49: 89 1d fc d6 11 00 mov %ebx,0x11d6fc <== 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 ); 10ef4f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef52: 53 push %ebx <== NOT EXECUTED 10ef53: e8 24 cb ff ff call 10ba7c <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 10ef58: e8 03 bf ff ff call 10ae60 <_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) */ 10ef5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef60: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 10ef64: 75 05 jne 10ef6b <_Thread_Handler+0x73> <== NOT EXECUTED { _init (); 10ef66: e8 85 6e 00 00 call 115df0 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 10ef6b: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 10ef71: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10ef74: 74 13 je 10ef89 <_Thread_Handler+0x91> <== NOT EXECUTED 10ef76: 72 0c jb 10ef84 <_Thread_Handler+0x8c> <== NOT EXECUTED 10ef78: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ef7b: 74 11 je 10ef8e <_Thread_Handler+0x96> <== NOT EXECUTED 10ef7d: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ef80: 75 36 jne 10efb8 <_Thread_Handler+0xc0> <== NOT EXECUTED 10ef82: eb 1a jmp 10ef9e <_Thread_Handler+0xa6> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 10ef84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef87: eb 1d jmp 10efa6 <_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 = 10ef89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef8c: eb 08 jmp 10ef96 <_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 = 10ef8e: 52 push %edx <== NOT EXECUTED 10ef8f: 52 push %edx <== NOT EXECUTED 10ef90: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10ef96: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10ef9c: eb 0e jmp 10efac <_Thread_Handler+0xb4> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 10ef9e: 50 push %eax <== NOT EXECUTED 10ef9f: 50 push %eax <== NOT EXECUTED 10efa0: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10efa6: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10efac: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 10efb2: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 10efb5: 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 ); 10efb8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10efbb: 53 push %ebx <== NOT EXECUTED 10efbc: e8 ec ca ff ff call 10baad <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 10efc1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10efc4: 6a 06 push $0x6 <== NOT EXECUTED 10efc6: 6a 01 push $0x1 <== NOT EXECUTED 10efc8: 6a 00 push $0x0 <== NOT EXECUTED 10efca: e8 f9 b1 ff ff call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED 0010b0cc <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10b0cc: 55 push %ebp <== NOT EXECUTED 10b0cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0cf: 53 push %ebx <== NOT EXECUTED 10b0d0: 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) 10b0d3: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10b0d8: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 10b0dc: 0f 94 c2 sete %dl <== NOT EXECUTED 10b0df: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 10b0e3: 0f 94 c0 sete %al <== NOT EXECUTED 10b0e6: 38 c2 cmp %al,%dl <== NOT EXECUTED 10b0e8: 74 0c je 10b0f6 <_Thread_Handler_initialization+0x2a> <== NOT EXECUTED == (!_Configuration_Table->stack_free_hook) ) ) _Internal_error_Occurred( 10b0ea: 52 push %edx <== NOT EXECUTED 10b0eb: 6a 0f push $0xf <== NOT EXECUTED 10b0ed: 6a 01 push $0x1 <== NOT EXECUTED 10b0ef: 6a 00 push $0x0 <== NOT EXECUTED 10b0f1: e8 d2 f0 ff ff call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10b0f6: c6 05 48 d7 11 00 00 movb $0x0,0x11d748 <== NOT EXECUTED _Thread_Executing = NULL; 10b0fd: c7 05 38 d7 11 00 00 movl $0x0,0x11d738 <== NOT EXECUTED 10b104: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10b107: c7 05 04 d7 11 00 00 movl $0x0,0x11d704 <== NOT EXECUTED 10b10e: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10b111: c7 05 fc d6 11 00 00 movl $0x0,0x11d6fc <== NOT EXECUTED 10b118: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10b11b: c7 05 1c d7 11 00 00 movl $0x0,0x11d71c <== NOT EXECUTED 10b122: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10b125: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b128: a3 18 d7 11 00 mov %eax,0x11d718 <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10b12d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b130: a3 44 d6 11 00 mov %eax,0x11d644 <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10b135: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b138: 0f b6 05 64 92 11 00 movzbl 0x119264,%eax <== NOT EXECUTED 10b13f: 40 inc %eax <== NOT EXECUTED 10b140: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b143: 50 push %eax <== NOT EXECUTED 10b144: e8 c9 0c 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b149: a3 40 d6 11 00 mov %eax,0x11d640 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10b14e: 0f b6 1d 64 92 11 00 movzbl 0x119264,%ebx <== NOT EXECUTED 10b155: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b157: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b159: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b15c: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b15f: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b161: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b168: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10b16b: 41 inc %ecx <== NOT EXECUTED 10b16c: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10b16f: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10b171: 76 e9 jbe 10b15c <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10b173: 50 push %eax <== NOT EXECUTED 10b174: 6a 08 push $0x8 <== NOT EXECUTED 10b176: 6a 01 push $0x1 <== NOT EXECUTED 10b178: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10b17d: 6a 01 push $0x1 <== NOT EXECUTED 10b17f: 6a 01 push $0x1 <== NOT EXECUTED 10b181: 6a 01 push $0x1 <== NOT EXECUTED 10b183: 68 d4 d7 11 00 push $0x11d7d4 <== NOT EXECUTED 10b188: e8 6b f5 ff ff call 10a6f8 <_Objects_Initialize_information> <== NOT EXECUTED 10b18d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10b190: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b193: c9 leave <== NOT EXECUTED 10b194: c3 ret <== NOT EXECUTED 0010aef8 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10aef8: 55 push %ebp <== NOT EXECUTED 10aef9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aefb: 57 push %edi <== NOT EXECUTED 10aefc: 56 push %esi <== NOT EXECUTED 10aefd: 53 push %ebx <== NOT EXECUTED 10aefe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af01: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10af04: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10af07: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10af0a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10af0d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10af10: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10af13: 88 45 f2 mov %al,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10af16: 85 d2 test %edx,%edx <== NOT EXECUTED 10af18: 75 2a jne 10af44 <_Thread_Initialize+0x4c> <== NOT EXECUTED actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10af1a: 51 push %ecx <== NOT EXECUTED 10af1b: 51 push %ecx <== NOT EXECUTED 10af1c: 56 push %esi <== NOT EXECUTED 10af1d: 53 push %ebx <== NOT EXECUTED 10af1e: e8 69 08 00 00 call 10b78c <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10af23: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af26: 85 c0 test %eax,%eax <== NOT EXECUTED 10af28: 74 04 je 10af2e <_Thread_Initialize+0x36> <== NOT EXECUTED 10af2a: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10af2c: 73 07 jae 10af35 <_Thread_Initialize+0x3d> <== NOT EXECUTED 10af2e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10af30: e9 8c 01 00 00 jmp 10b0c1 <_Thread_Initialize+0x1c9> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10af35: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10af3b: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10af42: eb 09 jmp 10af4d <_Thread_Initialize+0x55> <== NOT EXECUTED } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 10af44: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10af4b: 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 10af4d: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10af53: 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; 10af59: 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 ) { 10af5b: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10af5f: 74 17 je 10af78 <_Thread_Initialize+0x80> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10af61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af64: 6a 6c push $0x6c <== NOT EXECUTED 10af66: e8 92 0e 00 00 call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10af6b: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !fp_area ) { 10af6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af70: 85 c0 test %eax,%eax <== NOT EXECUTED 10af72: 0f 84 3b 01 00 00 je 10b0b3 <_Thread_Initialize+0x1bb> <== NOT EXECUTED fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10af78: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10af7e: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx) <== NOT EXECUTED * 10af84: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10af8b: 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 10af92: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10af99: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10afa0: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10afa7: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10afaa: a1 18 d7 11 00 mov 0x11d718,%eax <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10afaf: 31 ff xor %edi,%edi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10afb1: 85 c0 test %eax,%eax <== NOT EXECUTED 10afb3: 74 1d je 10afd2 <_Thread_Initialize+0xda> <== NOT EXECUTED extensions_area = _Workspace_Allocate( 10afb5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afb8: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10afbf: 50 push %eax <== NOT EXECUTED 10afc0: e8 38 0e 00 00 call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10afc5: 89 c7 mov %eax,%edi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10afc7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afca: 85 c0 test %eax,%eax <== NOT EXECUTED 10afcc: 0f 84 d1 00 00 00 je 10b0a3 <_Thread_Initialize+0x1ab> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10afd2: 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 ) { 10afd8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10afda: 85 ff test %edi,%edi <== NOT EXECUTED 10afdc: 75 10 jne 10afee <_Thread_Initialize+0xf6> <== NOT EXECUTED 10afde: eb 18 jmp 10aff8 <_Thread_Initialize+0x100> <== NOT EXECUTED uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) the_thread->extensions[i] = NULL; 10afe0: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax <== NOT EXECUTED 10afe6: 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++ ) 10afed: 42 inc %edx <== NOT EXECUTED 10afee: a1 18 d7 11 00 mov 0x11d718,%eax <== NOT EXECUTED 10aff3: 40 inc %eax <== NOT EXECUTED 10aff4: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aff6: 72 e8 jb 10afe0 <_Thread_Initialize+0xe8> <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10aff8: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10affb: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10b001: 8b 45 24 mov 0x24(%ebp),%eax <== NOT EXECUTED 10b004: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10b00a: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10b00d: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10b013: 83 7d 24 02 cmpl $0x2,0x24(%ebp) <== NOT EXECUTED 10b017: 75 08 jne 10b021 <_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; 10b019: a1 44 d6 11 00 mov 0x11d644,%eax <== NOT EXECUTED 10b01e: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10b021: 8b 45 2c mov 0x2c(%ebp),%eax <== NOT EXECUTED 10b024: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10b02a: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10b031: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10b038: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10b03f: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10b046: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10b049: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10b04c: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10b052: 52 push %edx <== NOT EXECUTED 10b053: 52 push %edx <== NOT EXECUTED 10b054: 50 push %eax <== NOT EXECUTED 10b055: 53 push %ebx <== NOT EXECUTED 10b056: e8 8d 05 00 00 call 10b5e8 <_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; 10b05b: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10b062: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10b065: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10b06c: 00 00 00 <== NOT EXECUTED 10b06f: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10b073: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b076: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b079: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10b07c: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10b07f: 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 ); 10b082: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b085: e8 92 0a 00 00 call 10bb1c <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10b08a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b08d: b2 01 mov $0x1,%dl <== NOT EXECUTED 10b08f: 84 c0 test %al,%al <== NOT EXECUTED 10b091: 75 2e jne 10b0c1 <_Thread_Initialize+0x1c9> <== NOT EXECUTED if ( extensions_area ) 10b093: 85 ff test %edi,%edi <== NOT EXECUTED 10b095: 74 0c je 10b0a3 <_Thread_Initialize+0x1ab> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10b097: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b09a: 57 push %edi <== NOT EXECUTED 10b09b: e8 48 0d 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10b0a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10b0a3: 85 f6 test %esi,%esi <== NOT EXECUTED 10b0a5: 74 0c je 10b0b3 <_Thread_Initialize+0x1bb> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10b0a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0aa: 56 push %esi <== NOT EXECUTED 10b0ab: e8 38 0d 00 00 call 10bde8 <_Workspace_Free> <== NOT EXECUTED 10b0b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10b0b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0b6: 53 push %ebx <== NOT EXECUTED 10b0b7: e8 20 07 00 00 call 10b7dc <_Thread_Stack_Free> <== NOT EXECUTED 10b0bc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b0be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10b0c1: 88 d0 mov %dl,%al <== NOT EXECUTED 10b0c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0c6: 5b pop %ebx <== NOT EXECUTED 10b0c7: 5e pop %esi <== NOT EXECUTED 10b0c8: 5f pop %edi <== NOT EXECUTED 10b0c9: c9 leave <== NOT EXECUTED 10b0ca: c3 ret <== NOT EXECUTED 0010e124 <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10e124: 55 push %ebp <== NOT EXECUTED 10e125: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e127: 57 push %edi <== NOT EXECUTED 10e128: 56 push %esi <== NOT EXECUTED 10e129: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10e12c: 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 ) { 10e12f: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10e135: 85 ff test %edi,%edi <== NOT EXECUTED 10e137: 74 12 je 10e14b <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10e139: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10e13f: be 24 d8 11 00 mov $0x11d824,%esi <== NOT EXECUTED 10e144: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10e149: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10e14b: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10e14f: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10e155: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10e158: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10e15e: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10e161: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10e167: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10e16d: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10e174: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10e176: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10e17b: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10e180: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10e186: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10e18c: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10e18f: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10e195: c7 00 f8 ee 10 00 movl $0x10eef8,(%eax) <== NOT EXECUTED 10e19b: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10e1a1: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10e1a7: 58 pop %eax <== NOT EXECUTED 10e1a8: 5e pop %esi <== NOT EXECUTED 10e1a9: 5f pop %edi <== NOT EXECUTED 10e1aa: c9 leave <== NOT EXECUTED 10e1ab: c3 ret <== NOT EXECUTED 0010e388 <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10e388: 55 push %ebp <== NOT EXECUTED 10e389: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e38b: 53 push %ebx <== NOT EXECUTED 10e38c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10e38f: 9c pushf <== NOT EXECUTED 10e390: fa cli <== NOT EXECUTED 10e391: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10e392: 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 10e399: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10e39f: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10e3a6: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10e3a9: 66 a1 2c d7 11 00 mov 0x11d72c,%ax <== NOT EXECUTED 10e3af: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10e3b5: 66 a3 2c d7 11 00 mov %ax,0x11d72c <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10e3bb: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10e3c1: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10e3c4: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10e3c6: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10e3c9: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10e3cc: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10e3ce: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10e3d1: 53 push %ebx <== NOT EXECUTED 10e3d2: 9d popf <== NOT EXECUTED 10e3d3: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e3d4: 66 8b 0d 2c d7 11 00 mov 0x11d72c,%cx <== NOT EXECUTED 10e3db: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e3dd: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e3df: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e3e3: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10e3e6: 66 8b 8c 00 a4 d7 11 mov 0x11d7a4(%eax,%eax,1),%cx <== NOT EXECUTED 10e3ed: 00 <== NOT EXECUTED 10e3ee: 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. 10e3f2: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e3f5: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10e3f8: 01 d0 add %edx,%eax <== NOT EXECUTED 10e3fa: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10e3fd: 8b 15 40 d6 11 00 mov 0x11d640,%edx <== NOT EXECUTED 10e403: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10e406: a3 04 d7 11 00 mov %eax,0x11d704 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10e40b: 8b 15 38 d7 11 00 mov 0x11d738,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10e411: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10e413: 74 0d je 10e422 <_Thread_Ready+0x9a> <== NOT EXECUTED 10e415: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10e419: 74 07 je 10e422 <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10e41b: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED _ISR_Enable( level ); 10e422: 53 push %ebx <== NOT EXECUTED 10e423: 9d popf <== NOT EXECUTED } 10e424: 5b pop %ebx <== NOT EXECUTED 10e425: c9 leave <== NOT EXECUTED 10e426: c3 ret <== NOT EXECUTED 0010ef00 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10ef00: 55 push %ebp <== NOT EXECUTED 10ef01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef03: 53 push %ebx <== NOT EXECUTED 10ef04: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ef07: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 10ef0a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10ef11: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10ef18: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 10ef1e: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10ef21: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10ef27: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10ef2a: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 10ef30: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10ef36: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ef39: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10ef3f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ef42: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10ef48: 53 push %ebx <== NOT EXECUTED 10ef49: e8 e2 ce ff ff call 10be30 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10ef4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef51: 84 c0 test %al,%al <== NOT EXECUTED 10ef53: 75 15 jne 10ef6a <_Thread_Reset+0x6a> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10ef55: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10ef59: 75 0f jne 10ef6a <_Thread_Reset+0x6a> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10ef5b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef5e: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10ef61: 50 push %eax <== NOT EXECUTED 10ef62: e8 09 d8 ff ff call 10c770 <_Watchdog_Remove> <== NOT EXECUTED 10ef67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 10ef6a: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 10ef70: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10ef73: 74 12 je 10ef87 <_Thread_Reset+0x87> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 10ef75: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10ef78: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ef7b: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 10ef7e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef81: 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 ); 10ef82: e9 85 d0 ff ff jmp 10c00c <_Thread_Set_priority> <== NOT EXECUTED } } 10ef87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef8a: c9 leave <== NOT EXECUTED 10ef8b: c3 ret <== NOT EXECUTED 0010e428 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 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 ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10e42d: 8b 0d 38 d7 11 00 mov 0x11d738,%ecx <== NOT EXECUTED ready = executing->ready; 10e433: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10e439: 9c pushf <== NOT EXECUTED 10e43a: fa cli <== NOT EXECUTED 10e43b: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10e43c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e43e: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10e441: 75 04 jne 10e447 <_Thread_Reset_timeslice+0x1f> <== NOT EXECUTED _ISR_Enable( level ); 10e443: 56 push %esi <== NOT EXECUTED 10e444: 9d popf <== NOT EXECUTED 10e445: eb 35 jmp 10e47c <_Thread_Reset_timeslice+0x54> <== NOT EXECUTED 10e447: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10e449: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e44c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e44f: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10e451: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10e454: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10e456: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10e459: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10e45c: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10e45e: 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 ); 10e461: 56 push %esi <== NOT EXECUTED 10e462: 9d popf <== NOT EXECUTED 10e463: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10e464: 3b 0d 04 d7 11 00 cmp 0x11d704,%ecx <== NOT EXECUTED 10e46a: 75 07 jne 10e473 <_Thread_Reset_timeslice+0x4b> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10e46c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e46e: a3 04 d7 11 00 mov %eax,0x11d704 <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10e473: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED _ISR_Enable( level ); 10e47a: 56 push %esi <== NOT EXECUTED 10e47b: 9d popf <== NOT EXECUTED } 10e47c: 5b pop %ebx <== NOT EXECUTED 10e47d: 5e pop %esi <== NOT EXECUTED 10e47e: c9 leave <== NOT EXECUTED 10e47f: c3 ret <== NOT EXECUTED 0010bf84 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10bf84: 55 push %ebp <== NOT EXECUTED 10bf85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf87: 53 push %ebx <== NOT EXECUTED 10bf88: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bf8b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10bf8e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bf90: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10bf94: 75 70 jne 10c006 <_Thread_Restart+0x82> <== NOT EXECUTED _Thread_Set_transient( the_thread ); 10bf96: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf99: 53 push %ebx <== NOT EXECUTED 10bf9a: e8 a1 01 00 00 call 10c140 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10bf9f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bfa2: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bfa5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bfa8: 53 push %ebx <== NOT EXECUTED 10bfa9: e8 52 2f 00 00 call 10ef00 <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10bfae: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bfb1: e8 46 2c 00 00 call 10ebfc <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10bfb6: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bfb9: e8 a2 2e 00 00 call 10ee60 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10bfbe: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bfc1: e8 ee 05 00 00 call 10c5b4 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10bfc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfc9: b0 01 mov $0x1,%al <== NOT EXECUTED 10bfcb: 3b 1d 84 0b 12 00 cmp 0x120b84,%ebx <== NOT EXECUTED 10bfd1: 75 33 jne 10c006 <_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 10bfd3: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10bfda: 74 12 je 10bfee <_Thread_Restart+0x6a> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10bfdc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfdf: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10bfe5: 50 push %eax <== NOT EXECUTED 10bfe6: e8 43 09 00 00 call 10c92e <_CPU_Context_restore_fp> <== NOT EXECUTED 10bfeb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10bfee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bff1: a1 84 0b 12 00 mov 0x120b84,%eax <== NOT EXECUTED 10bff6: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10bffb: 50 push %eax <== NOT EXECUTED 10bffc: e8 1c 09 00 00 call 10c91d <_CPU_Context_restore> <== NOT EXECUTED 10c001: b0 01 mov $0x1,%al <== NOT EXECUTED 10c003: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10c006: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c009: c9 leave <== NOT EXECUTED 10c00a: c3 ret <== NOT EXECUTED 0010c994 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10c994: 55 push %ebp <== NOT EXECUTED 10c995: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c997: 53 push %ebx <== NOT EXECUTED 10c998: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c99b: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10c99e: 9c pushf <== NOT EXECUTED 10c99f: fa cli <== NOT EXECUTED 10c9a0: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10c9a1: 84 c0 test %al,%al <== NOT EXECUTED 10c9a3: 74 09 je 10c9ae <_Thread_Resume+0x1a> <== NOT EXECUTED the_thread->suspend_count = 0; 10c9a5: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) <== NOT EXECUTED 10c9ac: eb 03 jmp 10c9b1 <_Thread_Resume+0x1d> <== NOT EXECUTED else the_thread->suspend_count--; 10c9ae: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10c9b1: 83 79 70 00 cmpl $0x0,0x70(%ecx) <== NOT EXECUTED 10c9b5: 74 04 je 10c9bb <_Thread_Resume+0x27> <== NOT EXECUTED _ISR_Enable( level ); 10c9b7: 53 push %ebx <== NOT EXECUTED 10c9b8: 9d popf <== NOT EXECUTED 10c9b9: eb 77 jmp 10ca32 <_Thread_Resume+0x9e> <== NOT EXECUTED return; } current_state = the_thread->current_state; 10c9bb: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10c9be: a8 02 test $0x2,%al <== NOT EXECUTED 10c9c0: 74 6e je 10ca30 <_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( 10c9c2: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED current_state = 10c9c5: 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 ) ) { 10c9c8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9ca: 75 64 jne 10ca30 <_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 10c9cc: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10c9d2: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10c9d9: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10c9dc: 66 a1 c8 94 12 00 mov 0x1294c8,%ax <== NOT EXECUTED 10c9e2: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10c9e8: 66 a3 c8 94 12 00 mov %ax,0x1294c8 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10c9ee: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10c9f4: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10c9f7: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10c9f9: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10c9fc: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10c9ff: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10ca01: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10ca04: 53 push %ebx <== NOT EXECUTED 10ca05: 9d popf <== NOT EXECUTED 10ca06: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10ca07: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10ca0a: a1 a0 94 12 00 mov 0x1294a0,%eax <== NOT EXECUTED 10ca0f: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10ca12: 73 1c jae 10ca30 <_Thread_Resume+0x9c> <== NOT EXECUTED _Thread_Heir = the_thread; 10ca14: 89 0d a0 94 12 00 mov %ecx,0x1294a0 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10ca1a: a1 d4 94 12 00 mov 0x1294d4,%eax <== NOT EXECUTED 10ca1f: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10ca23: 75 04 jne 10ca29 <_Thread_Resume+0x95> <== NOT EXECUTED 10ca25: 85 d2 test %edx,%edx <== NOT EXECUTED 10ca27: 75 07 jne 10ca30 <_Thread_Resume+0x9c> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10ca29: c6 05 e4 94 12 00 01 movb $0x1,0x1294e4 <== NOT EXECUTED } } } _ISR_Enable( level ); 10ca30: 53 push %ebx <== NOT EXECUTED 10ca31: 9d popf <== NOT EXECUTED } 10ca32: 5b pop %ebx <== NOT EXECUTED 10ca33: c9 leave <== NOT EXECUTED 10ca34: c3 ret <== NOT EXECUTED 0010b5e8 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10b5e8: 55 push %ebp <== NOT EXECUTED 10b5e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5eb: 56 push %esi <== NOT EXECUTED 10b5ec: 53 push %ebx <== NOT EXECUTED 10b5ed: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b5f0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED the_thread->current_priority = new_priority; 10b5f3: 89 5a 14 mov %ebx,0x14(%edx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10b5f6: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 10b5f9: 03 05 40 d6 11 00 add 0x11d640,%eax <== NOT EXECUTED 10b5ff: 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. */ 10b605: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10b607: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10b60a: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10b60d: 8d 84 09 a4 d7 11 00 lea 0x11d7a4(%ecx,%ecx,1),%eax <== NOT EXECUTED 10b614: 89 82 90 00 00 00 mov %eax,0x90(%edx) <== NOT EXECUTED bool do_dump ); 10b61a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b61f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b621: d3 e6 shl %cl,%esi <== NOT EXECUTED 10b623: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10b625: 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 10b62c: f7 d1 not %ecx <== NOT EXECUTED 10b62e: 66 89 8a 98 00 00 00 mov %cx,0x98(%edx) <== NOT EXECUTED * sizes. * 10b635: 83 e3 0f and $0xf,%ebx <== NOT EXECUTED 10b638: 88 d9 mov %bl,%cl <== NOT EXECUTED 10b63a: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10b63c: 66 89 82 96 00 00 00 mov %ax,0x96(%edx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10b643: f7 d0 not %eax <== NOT EXECUTED 10b645: 66 89 82 9a 00 00 00 mov %ax,0x9a(%edx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10b64c: 5b pop %ebx <== NOT EXECUTED 10b64d: 5e pop %esi <== NOT EXECUTED 10b64e: c9 leave <== NOT EXECUTED 10b64f: c3 ret <== NOT EXECUTED 0010b650 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10b650: 55 push %ebp <== NOT EXECUTED 10b651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b653: 56 push %esi <== NOT EXECUTED 10b654: 53 push %ebx <== NOT EXECUTED 10b655: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b658: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10b65b: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10b661: 9c pushf <== NOT EXECUTED 10b662: fa cli <== NOT EXECUTED 10b663: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10b664: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 10b667: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b669: 74 0c je 10b677 <_Thread_Set_state+0x27> <== NOT EXECUTED the_thread->current_state = 10b66b: 09 c8 or %ecx,%eax <== NOT EXECUTED 10b66d: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10b670: 56 push %esi <== NOT EXECUTED 10b671: 9d popf <== NOT EXECUTED 10b672: e9 a0 00 00 00 jmp 10b717 <_Thread_Set_state+0xc7> <== NOT EXECUTED return; } the_thread->current_state = state; 10b677: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b67a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10b67c: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10b67f: 75 39 jne 10b6ba <_Thread_Set_state+0x6a> <== NOT EXECUTED 10b681: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b684: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b686: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b68d: 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 10b690: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b696: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b69d: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b6a0: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b6a4: 75 1e jne 10b6c4 <_Thread_Set_state+0x74> <== NOT EXECUTED * to be resized 10b6a6: 66 a1 2c d7 11 00 mov 0x11d72c,%ax <== NOT EXECUTED 10b6ac: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b6b2: 66 a3 2c d7 11 00 mov %ax,0x11d72c <== NOT EXECUTED 10b6b8: eb 0a jmp 10b6c4 <_Thread_Set_state+0x74> <== NOT EXECUTED 10b6ba: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b6bc: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b6bf: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b6c2: 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 ); 10b6c4: 56 push %esi <== NOT EXECUTED 10b6c5: 9d popf <== NOT EXECUTED 10b6c6: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10b6c7: 3b 1d 04 d7 11 00 cmp 0x11d704,%ebx <== NOT EXECUTED 10b6cd: 75 37 jne 10b706 <_Thread_Set_state+0xb6> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10b6cf: 66 8b 0d 2c d7 11 00 mov 0x11d72c,%cx <== NOT EXECUTED 10b6d6: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b6d8: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b6da: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10b6de: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10b6e1: 66 8b 8c 00 a4 d7 11 mov 0x11d7a4(%eax,%eax,1),%cx <== NOT EXECUTED 10b6e8: 00 <== NOT EXECUTED 10b6e9: 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. 10b6ed: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10b6f0: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10b6f3: 01 d0 add %edx,%eax <== NOT EXECUTED 10b6f5: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b6f8: 8b 15 40 d6 11 00 mov 0x11d640,%edx <== NOT EXECUTED 10b6fe: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b701: a3 04 d7 11 00 mov %eax,0x11d704 <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10b706: 3b 1d 38 d7 11 00 cmp 0x11d738,%ebx <== NOT EXECUTED 10b70c: 75 07 jne 10b715 <_Thread_Set_state+0xc5> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b70e: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED _ISR_Enable( level ); 10b715: 56 push %esi <== NOT EXECUTED 10b716: 9d popf <== NOT EXECUTED } 10b717: 5b pop %ebx <== NOT EXECUTED 10b718: 5e pop %esi <== NOT EXECUTED 10b719: c9 leave <== NOT EXECUTED 10b71a: c3 ret <== NOT EXECUTED 0010b71c <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10b71c: 55 push %ebp <== NOT EXECUTED 10b71d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b71f: 56 push %esi <== NOT EXECUTED 10b720: 53 push %ebx <== NOT EXECUTED 10b721: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10b724: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10b72a: 9c pushf <== NOT EXECUTED 10b72b: fa cli <== NOT EXECUTED 10b72c: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10b72d: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10b730: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b732: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10b735: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10b738: 85 d2 test %edx,%edx <== NOT EXECUTED 10b73a: 75 4a jne 10b786 <_Thread_Set_transient+0x6a> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b73c: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10b73e: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10b741: 75 39 jne 10b77c <_Thread_Set_transient+0x60> <== NOT EXECUTED 10b743: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b746: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b748: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b74f: 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 10b752: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b758: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b75f: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b762: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b766: 75 1e jne 10b786 <_Thread_Set_transient+0x6a> <== NOT EXECUTED * to be resized 10b768: 66 a1 2c d7 11 00 mov 0x11d72c,%ax <== NOT EXECUTED 10b76e: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b774: 66 a3 2c d7 11 00 mov %ax,0x11d72c <== NOT EXECUTED 10b77a: eb 0a jmp 10b786 <_Thread_Set_transient+0x6a> <== NOT EXECUTED 10b77c: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b77e: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b781: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b784: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10b786: 56 push %esi <== NOT EXECUTED 10b787: 9d popf <== NOT EXECUTED } 10b788: 5b pop %ebx <== NOT EXECUTED 10b789: 5e pop %esi <== NOT EXECUTED 10b78a: c9 leave <== NOT EXECUTED 10b78b: c3 ret <== NOT EXECUTED 0010b78c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10b78c: 55 push %ebp <== NOT EXECUTED 10b78d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b78f: 53 push %ebx <== NOT EXECUTED 10b790: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b793: a1 60 92 11 00 mov 0x119260,%eax <== NOT EXECUTED 10b798: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b79b: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b79d: 73 02 jae 10b7a1 <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10b79f: 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 ) { 10b7a1: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10b7a6: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10b7a9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7ab: 74 08 je 10b7b5 <_Thread_Stack_Allocate+0x29> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10b7ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7b0: 53 push %ebx <== NOT EXECUTED 10b7b1: ff d0 call *%eax <== NOT EXECUTED 10b7b3: eb 09 jmp 10b7be <_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 ); 10b7b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7b8: 53 push %ebx <== NOT EXECUTED 10b7b9: e8 3f 06 00 00 call 10bdfd <_Workspace_Allocate> <== NOT EXECUTED 10b7be: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b7c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( !stack_addr ) 10b7c3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b7c5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b7c7: 0f 95 c0 setne %al <== NOT EXECUTED 10b7ca: f7 d8 neg %eax <== NOT EXECUTED 10b7cc: 21 d8 and %ebx,%eax <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10b7ce: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7d1: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) <== NOT EXECUTED return the_stack_size; } 10b7d7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b7da: c9 leave <== NOT EXECUTED 10b7db: c3 ret <== NOT EXECUTED 0010b7dc <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10b7dc: 55 push %ebp <== NOT EXECUTED 10b7dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7df: 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 ) 10b7e2: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10b7e9: 74 21 je 10b80c <_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 ) 10b7eb: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10b7f0: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10b7f3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b7f5: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10b7fb: 74 06 je 10b803 <_Thread_Stack_Free+0x27> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10b7fd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10b800: 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)( 10b801: ff e1 jmp *%ecx <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b803: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10b806: 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 ); 10b807: e9 dc 05 00 00 jmp 10bde8 <_Workspace_Free> <== NOT EXECUTED } 10b80c: c9 leave <== NOT EXECUTED 10b80d: c3 ret <== NOT EXECUTED 0010b868 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10b868: 55 push %ebp <== NOT EXECUTED 10b869: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b86b: 53 push %ebx <== NOT EXECUTED 10b86c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b86f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10b872: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b874: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10b878: 74 42 je 10b8bc <_Thread_Start+0x54> <== NOT EXECUTED the_thread->Start.entry_point = (Thread_Entry) entry_point; 10b87a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b87d: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10b883: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b886: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10b88c: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b88f: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10b895: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10b898: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10b89e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b8a1: 53 push %ebx <== NOT EXECUTED 10b8a2: e8 7d 28 00 00 call 10e124 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10b8a7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b8aa: e8 d9 2a 00 00 call 10e388 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10b8af: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b8b2: e8 d9 02 00 00 call 10bb90 <_User_extensions_Thread_start> <== NOT EXECUTED 10b8b7: b0 01 mov $0x1,%al <== NOT EXECUTED 10b8b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10b8bc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b8bf: c9 leave <== NOT EXECUTED 10b8c0: c3 ret <== NOT EXECUTED 0010b810 <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10b810: 55 push %ebp <== NOT EXECUTED 10b811: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b813: 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( 10b816: c7 05 18 d8 11 00 03 movl $0x3,0x11d818 <== NOT EXECUTED 10b81d: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10b820: c6 05 48 d7 11 00 00 movb $0x0,0x11d748 <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10b827: a1 04 d7 11 00 mov 0x11d704,%eax <== NOT EXECUTED 10b82c: a3 38 d7 11 00 mov %eax,0x11d738 <== 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 ) 10b831: 83 b8 ec 00 00 00 00 cmpl $0x0,0xec(%eax) <== NOT EXECUTED 10b838: 74 11 je 10b84b <_Thread_Start_multitasking+0x3b> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10b83a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b83d: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10b842: 50 push %eax <== NOT EXECUTED 10b843: e8 86 06 00 00 call 10bece <_CPU_Context_restore_fp> <== NOT EXECUTED 10b848: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10b84b: 50 push %eax <== NOT EXECUTED 10b84c: 50 push %eax <== NOT EXECUTED 10b84d: a1 04 d7 11 00 mov 0x11d704,%eax <== NOT EXECUTED 10b852: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10b857: 50 push %eax <== NOT EXECUTED 10b858: 68 60 d6 11 00 push $0x11d660 <== NOT EXECUTED 10b85d: e8 2e 06 00 00 call 10be90 <_CPU_Context_switch> <== NOT EXECUTED 10b862: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b865: c9 leave <== NOT EXECUTED 10b866: c3 ret <== NOT EXECUTED 0010cd14 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10cd14: 55 push %ebp <== NOT EXECUTED 10cd15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd17: 56 push %esi <== NOT EXECUTED 10cd18: 53 push %ebx <== NOT EXECUTED 10cd19: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cd1c: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cd22: 9c pushf <== NOT EXECUTED 10cd23: fa cli <== NOT EXECUTED 10cd24: 5e pop %esi <== NOT EXECUTED the_thread->suspend_count++; 10cd25: ff 43 70 incl 0x70(%ebx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cd28: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cd2b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd2d: 74 0d je 10cd3c <_Thread_Suspend+0x28> <== NOT EXECUTED the_thread->current_state = 10cd2f: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10cd32: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10cd35: 56 push %esi <== NOT EXECUTED 10cd36: 9d popf <== NOT EXECUTED 10cd37: e9 a4 00 00 00 jmp 10cde0 <_Thread_Suspend+0xcc> <== NOT EXECUTED return; } the_thread->current_state = STATES_SUSPENDED; 10cd3c: c7 43 10 02 00 00 00 movl $0x2,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cd43: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cd45: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cd48: 75 39 jne 10cd83 <_Thread_Suspend+0x6f> <== NOT EXECUTED 10cd4a: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10cd4d: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cd4f: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10cd56: 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 10cd59: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cd5f: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cd66: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cd69: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cd6d: 75 1e jne 10cd8d <_Thread_Suspend+0x79> <== NOT EXECUTED * to be resized 10cd6f: 66 a1 c8 94 12 00 mov 0x1294c8,%ax <== NOT EXECUTED 10cd75: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cd7b: 66 a3 c8 94 12 00 mov %ax,0x1294c8 <== NOT EXECUTED 10cd81: eb 0a jmp 10cd8d <_Thread_Suspend+0x79> <== NOT EXECUTED 10cd83: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cd85: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cd88: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cd8b: 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 ); 10cd8d: 56 push %esi <== NOT EXECUTED 10cd8e: 9d popf <== NOT EXECUTED 10cd8f: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10cd90: 3b 1d a0 94 12 00 cmp 0x1294a0,%ebx <== NOT EXECUTED 10cd96: 75 37 jne 10cdcf <_Thread_Suspend+0xbb> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cd98: 66 8b 0d c8 94 12 00 mov 0x1294c8,%cx <== NOT EXECUTED 10cd9f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cda1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cda3: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10cda7: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10cdaa: 66 8b 8c 00 40 95 12 mov 0x129540(%eax,%eax,1),%cx <== NOT EXECUTED 10cdb1: 00 <== NOT EXECUTED 10cdb2: 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. 10cdb6: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10cdb9: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10cdbc: 01 d0 add %edx,%eax <== NOT EXECUTED 10cdbe: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10cdc1: 8b 15 dc 93 12 00 mov 0x1293dc,%edx <== NOT EXECUTED 10cdc7: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10cdca: a3 a0 94 12 00 mov %eax,0x1294a0 <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cdcf: 3b 1d d4 94 12 00 cmp 0x1294d4,%ebx <== NOT EXECUTED 10cdd5: 75 07 jne 10cdde <_Thread_Suspend+0xca> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10cdd7: c6 05 e4 94 12 00 01 movb $0x1,0x1294e4 <== NOT EXECUTED _ISR_Enable( level ); 10cdde: 56 push %esi <== NOT EXECUTED 10cddf: 9d popf <== NOT EXECUTED } 10cde0: 5b pop %ebx <== NOT EXECUTED 10cde1: 5e pop %esi <== NOT EXECUTED 10cde2: c9 leave <== NOT EXECUTED 10cde3: c3 ret <== NOT EXECUTED 0010b8c4 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10b8c4: 55 push %ebp <== NOT EXECUTED 10b8c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b8c7: 53 push %ebx <== NOT EXECUTED 10b8c8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10b8cb: 8b 1d 38 d7 11 00 mov 0x11d738,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10b8d1: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10b8d5: 74 4c je 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10b8d7: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10b8db: 75 46 jne 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10b8dd: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10b8e0: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b8e3: 72 3e jb 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b8e5: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b8e8: 76 07 jbe 10b8f1 <_Thread_Tickle_timeslice+0x2d> <== NOT EXECUTED 10b8ea: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b8ed: 75 34 jne 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b8ef: eb 1a jmp 10b90b <_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 ) { 10b8f1: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b8f4: 48 dec %eax <== NOT EXECUTED 10b8f5: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b8f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8fa: 7f 27 jg 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED _Thread_Reset_timeslice(); 10b8fc: e8 27 2b 00 00 call 10e428 <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b901: a1 44 d6 11 00 mov 0x11d644,%eax <== NOT EXECUTED 10b906: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b909: eb 18 jmp 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10b90b: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b90e: 48 dec %eax <== NOT EXECUTED 10b90f: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b912: 85 c0 test %eax,%eax <== NOT EXECUTED 10b914: 75 0d jne 10b923 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10b916: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b919: 53 push %ebx <== NOT EXECUTED 10b91a: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10b920: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } 10b923: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b926: c9 leave <== NOT EXECUTED 10b927: c3 ret <== NOT EXECUTED 0010b928 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10b928: 55 push %ebp <== NOT EXECUTED 10b929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b92b: 56 push %esi <== NOT EXECUTED 10b92c: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10b92d: 8b 0d 38 d7 11 00 mov 0x11d738,%ecx <== NOT EXECUTED ready = executing->ready; 10b933: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10b939: 9c pushf <== NOT EXECUTED 10b93a: fa cli <== NOT EXECUTED 10b93b: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10b93c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b93e: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10b941: 74 2e je 10b971 <_Thread_Yield_processor+0x49> <== NOT EXECUTED 10b943: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10b945: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10b948: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b94b: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10b94d: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10b950: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b952: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10b955: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10b958: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10b95a: 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 ); 10b95d: 56 push %esi <== NOT EXECUTED 10b95e: 9d popf <== NOT EXECUTED 10b95f: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10b960: 3b 0d 04 d7 11 00 cmp 0x11d704,%ecx <== NOT EXECUTED 10b966: 75 11 jne 10b979 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10b968: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b96a: a3 04 d7 11 00 mov %eax,0x11d704 <== NOT EXECUTED 10b96f: eb 08 jmp 10b979 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10b971: 3b 0d 04 d7 11 00 cmp 0x11d704,%ecx <== NOT EXECUTED 10b977: 74 07 je 10b980 <_Thread_Yield_processor+0x58> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b979: c6 05 48 d7 11 00 01 movb $0x1,0x11d748 <== NOT EXECUTED _ISR_Enable( level ); 10b980: 56 push %esi <== NOT EXECUTED 10b981: 9d popf <== NOT EXECUTED } 10b982: 5b pop %ebx <== NOT EXECUTED 10b983: 5e pop %esi <== NOT EXECUTED 10b984: c9 leave <== NOT EXECUTED 10b985: c3 ret <== NOT EXECUTED 0010a974 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10a974: 55 push %ebp <== NOT EXECUTED 10a975: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a977: 53 push %ebx <== NOT EXECUTED 10a978: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a97b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a97e: 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; 10a981: 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 ) ) { 10a988: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10a98c: 75 1a jne 10a9a8 <_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 */ 10a98e: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10a995: 50 push %eax <== NOT EXECUTED 10a996: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10a997: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a99a: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10a99d: 50 push %eax <== NOT EXECUTED 10a99e: e8 71 13 00 00 call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED 10a9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9a6: eb 02 jmp 10a9aa <_Thread_blocking_operation_Cancel+0x36> <== NOT EXECUTED } else _ISR_Enable( level ); 10a9a8: 50 push %eax <== NOT EXECUTED 10a9a9: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a9aa: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10a9b1: 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 } 10a9b4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a9b7: c9 leave <== NOT EXECUTED 10a9b8: e9 23 01 00 00 jmp 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 0010b198 <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10b198: 55 push %ebp <== NOT EXECUTED 10b199: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b19b: 53 push %ebx <== NOT EXECUTED 10b19c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b19f: 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 ) 10b1a2: b8 e4 b1 10 00 mov $0x10b1e4,%eax <== NOT EXECUTED 10b1a7: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b1ab: 74 05 je 10b1b2 <_Thread_queue_Dequeue+0x1a> <== NOT EXECUTED 10b1ad: b8 ac e1 10 00 mov $0x10e1ac,%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 ); 10b1b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b1b5: 53 push %ebx <== NOT EXECUTED 10b1b6: ff d0 call *%eax <== NOT EXECUTED 10b1b8: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10b1ba: 9c pushf <== NOT EXECUTED 10b1bb: fa cli <== NOT EXECUTED 10b1bc: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10b1bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1c0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1c2: 75 16 jne 10b1da <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED sync_state = the_thread_queue->sync_state; if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b1c4: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10b1c7: 48 dec %eax <== NOT EXECUTED 10b1c8: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b1cb: 77 0d ja 10b1da <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b1cd: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10b1d4: 8b 15 38 d7 11 00 mov 0x11d738,%edx <== NOT EXECUTED } } _ISR_Enable( level ); 10b1da: 51 push %ecx <== NOT EXECUTED 10b1db: 9d popf <== NOT EXECUTED return the_thread; } 10b1dc: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b1de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1e1: c9 leave <== NOT EXECUTED 10b1e2: c3 ret <== NOT EXECUTED 0010e1ac <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10e1ac: 55 push %ebp <== NOT EXECUTED 10e1ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e1af: 56 push %esi <== NOT EXECUTED 10e1b0: 53 push %ebx <== NOT EXECUTED 10e1b1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10e1b4: 9c pushf <== NOT EXECUTED 10e1b5: fa cli <== NOT EXECUTED 10e1b6: 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( 10e1b7: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10e1b9: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10e1bc: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10e1be: 74 43 je 10e203 <_Thread_queue_Dequeue_fifo+0x57> <== NOT EXECUTED 10e1c0: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e1c2: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10e1c4: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10e1c7: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10e1c9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10e1d0: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10e1d4: 74 06 je 10e1dc <_Thread_queue_Dequeue_fifo+0x30> <== NOT EXECUTED _ISR_Enable( level ); 10e1d6: 56 push %esi <== NOT EXECUTED 10e1d7: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e1d8: 51 push %ecx <== NOT EXECUTED 10e1d9: 51 push %ecx <== NOT EXECUTED 10e1da: eb 17 jmp 10e1f3 <_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 */ 10e1dc: 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 ); 10e1e3: 56 push %esi <== NOT EXECUTED 10e1e4: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e1e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e1e8: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10e1eb: 50 push %eax <== NOT EXECUTED 10e1ec: e8 23 db ff ff call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e1f1: 58 pop %eax <== NOT EXECUTED 10e1f2: 5a pop %edx <== NOT EXECUTED 10e1f3: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10e1f8: 53 push %ebx <== NOT EXECUTED 10e1f9: e8 e2 c8 ff ff call 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 10e1fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e201: eb 04 jmp 10e207 <_Thread_queue_Dequeue_fifo+0x5b> <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10e203: 56 push %esi <== NOT EXECUTED 10e204: 9d popf <== NOT EXECUTED 10e205: 31 db xor %ebx,%ebx <== NOT EXECUTED return NULL; } 10e207: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e209: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e20c: 5b pop %ebx <== NOT EXECUTED 10e20d: 5e pop %esi <== NOT EXECUTED 10e20e: c9 leave <== NOT EXECUTED 10e20f: c3 ret <== NOT EXECUTED 0010b1e4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10b1e4: 55 push %ebp <== NOT EXECUTED 10b1e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1e7: 57 push %edi <== NOT EXECUTED 10b1e8: 56 push %esi <== NOT EXECUTED 10b1e9: 53 push %ebx <== NOT EXECUTED 10b1ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b1ed: 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 ); 10b1f0: 9c pushf <== NOT EXECUTED 10b1f1: fa cli <== NOT EXECUTED 10b1f2: 8f 45 e8 popl -0x18(%ebp) <== NOT EXECUTED 10b1f5: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b1f7: 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( 10b1f9: 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 ] ) ) { 10b1fc: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 10b1ff: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 10b203: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b205: 74 1b je 10b222 <_Thread_queue_Dequeue_priority+0x3e> <== NOT EXECUTED the_thread = (Thread_Control *) 10b207: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10b20a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10b211: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10b214: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10b216: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10b219: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10b21c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b21e: 75 18 jne 10b238 <_Thread_queue_Dequeue_priority+0x54> <== NOT EXECUTED 10b220: eb 49 jmp 10b26b <_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++ ) { 10b222: 42 inc %edx <== NOT EXECUTED 10b223: 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 ; 10b226: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10b229: 75 ce jne 10b1f9 <_Thread_queue_Dequeue_priority+0x15> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10b22b: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b22e: 9d popf <== NOT EXECUTED 10b22f: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 10b236: eb 6d jmp 10b2a5 <_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; 10b238: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b23b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10b23e: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10b240: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10b242: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10b245: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10b247: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10b24a: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b24d: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b250: 74 1e je 10b270 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10b252: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10b255: 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; 10b258: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10b25b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b25e: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10b261: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10b264: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b267: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b269: eb 05 jmp 10b270 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED } } else { previous_node->next = next_node; 10b26b: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10b26d: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b270: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10b274: 74 08 je 10b27e <_Thread_queue_Dequeue_priority+0x9a> <== NOT EXECUTED _ISR_Enable( level ); 10b276: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b279: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b27a: 51 push %ecx <== NOT EXECUTED 10b27b: 51 push %ecx <== NOT EXECUTED 10b27c: eb 19 jmp 10b297 <_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 */ 10b27e: 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 ); 10b285: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b288: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10b289: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b28c: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b28f: 50 push %eax <== NOT EXECUTED 10b290: e8 7f 0a 00 00 call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b295: 58 pop %eax <== NOT EXECUTED 10b296: 5a pop %edx <== NOT EXECUTED 10b297: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10b29c: 53 push %ebx <== NOT EXECUTED 10b29d: e8 3e f8 ff ff call 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 10b2a2: 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 ); } 10b2a5: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b2a8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b2ab: 5b pop %ebx <== NOT EXECUTED 10b2ac: 5e pop %esi <== NOT EXECUTED 10b2ad: 5f pop %edi <== NOT EXECUTED 10b2ae: c9 leave <== NOT EXECUTED 10b2af: c3 ret <== NOT EXECUTED 0010e210 <_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 ) { 10e210: 55 push %ebp <== NOT EXECUTED 10e211: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e213: 56 push %esi <== NOT EXECUTED 10e214: 53 push %ebx <== NOT EXECUTED 10e215: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e218: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10e21b: 9c pushf <== NOT EXECUTED 10e21c: fa cli <== NOT EXECUTED 10e21d: 5b pop %ebx <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10e21e: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10e221: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10e228: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10e22b: 75 17 jne 10e244 <_Thread_queue_Enqueue_fifo+0x34> <== NOT EXECUTED 10e22d: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10e230: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10e232: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10e235: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED 10e238: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10e23a: 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; 10e23d: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10e240: 53 push %ebx <== NOT EXECUTED 10e241: 9d popf <== NOT EXECUTED 10e242: eb 05 jmp 10e249 <_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; 10e244: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e247: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return sync_state; } 10e249: 89 f0 mov %esi,%eax <== NOT EXECUTED 10e24b: 5b pop %ebx <== NOT EXECUTED 10e24c: 5e pop %esi <== NOT EXECUTED 10e24d: c9 leave <== NOT EXECUTED 10e24e: c3 ret <== NOT EXECUTED 0010b33c <_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 ) { 10b33c: 55 push %ebp <== NOT EXECUTED 10b33d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b33f: 57 push %edi <== NOT EXECUTED 10b340: 56 push %esi <== NOT EXECUTED 10b341: 53 push %ebx <== NOT EXECUTED 10b342: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b345: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b348: 8d 41 3c lea 0x3c(%ecx),%eax <== NOT EXECUTED 10b34b: 89 41 38 mov %eax,0x38(%ecx) <== NOT EXECUTED 10b34e: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED 10b355: 8d 41 38 lea 0x38(%ecx),%eax <== NOT EXECUTED 10b358: 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; 10b35b: 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. 10b35e: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b360: c1 e8 06 shr $0x6,%eax <== NOT EXECUTED header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10b363: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b366: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b369: 01 c3 add %eax,%ebx <== NOT EXECUTED block_state = the_thread_queue->state; 10b36b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b36e: 8b 52 38 mov 0x38(%edx),%edx <== NOT EXECUTED 10b371: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10b374: f7 c7 20 00 00 00 test $0x20,%edi <== NOT EXECUTED 10b37a: 75 77 jne 10b3f3 <_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 10b37c: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 10b37f: 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; 10b382: 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 ); 10b385: 9c pushf <== NOT EXECUTED 10b386: fa cli <== NOT EXECUTED 10b387: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10b388: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10b38b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b38e: 8b 14 18 mov (%eax,%ebx,1),%edx <== NOT EXECUTED 10b391: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) <== NOT EXECUTED 10b398: eb 1b jmp 10b3b5 <_Thread_queue_Enqueue_priority+0x79> <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b39a: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED 10b39d: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED if ( priority <= search_priority ) 10b3a0: 39 df cmp %ebx,%edi <== NOT EXECUTED 10b3a2: 76 16 jbe 10b3ba <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10b3a4: 56 push %esi <== NOT EXECUTED 10b3a5: 9d popf <== NOT EXECUTED 10b3a6: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b3a7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b3aa: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b3ad: 75 04 jne 10b3b3 <_Thread_queue_Enqueue_priority+0x77> <== NOT EXECUTED _ISR_Enable( level ); 10b3af: 56 push %esi <== NOT EXECUTED 10b3b0: 9d popf <== NOT EXECUTED 10b3b1: eb d2 jmp 10b385 <_Thread_queue_Enqueue_priority+0x49> <== NOT EXECUTED goto restart_forward_search; } search_thread = 10b3b3: 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 ) ) { 10b3b5: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10b3b8: 75 e0 jne 10b39a <_Thread_queue_Enqueue_priority+0x5e> <== NOT EXECUTED 10b3ba: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b3bd: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10b3bf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b3c2: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b3c6: 0f 85 b4 00 00 00 jne 10b480 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b3cc: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b3d3: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b3d6: 0f 84 87 00 00 00 je 10b463 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10b3dc: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b3df: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b3e1: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b3e4: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10b3e6: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b3e9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b3ec: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b3ef: 56 push %esi <== NOT EXECUTED 10b3f0: 9d popf <== NOT EXECUTED 10b3f1: eb 69 jmp 10b45c <_Thread_queue_Enqueue_priority+0x120> <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10b3f3: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10b3f6: 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; 10b3f9: 0f b6 05 64 92 11 00 movzbl 0x119264,%eax <== NOT EXECUTED 10b400: 40 inc %eax <== NOT EXECUTED 10b401: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10b404: 9c pushf <== NOT EXECUTED 10b405: fa cli <== NOT EXECUTED 10b406: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10b407: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b40a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b40c: eb 1c jmp 10b42a <_Thread_queue_Enqueue_priority+0xee> <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b40e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10b411: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( priority >= search_priority ) 10b414: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10b416: 73 16 jae 10b42e <_Thread_queue_Enqueue_priority+0xf2> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10b418: 56 push %esi <== NOT EXECUTED 10b419: 9d popf <== NOT EXECUTED 10b41a: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b41b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b41e: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b421: 75 04 jne 10b427 <_Thread_queue_Enqueue_priority+0xeb> <== NOT EXECUTED _ISR_Enable( level ); 10b423: 56 push %esi <== NOT EXECUTED 10b424: 9d popf <== NOT EXECUTED 10b425: eb d2 jmp 10b3f9 <_Thread_queue_Enqueue_priority+0xbd> <== NOT EXECUTED goto restart_reverse_search; } search_thread = (Thread_Control *) 10b427: 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 ) ) { 10b42a: 39 da cmp %ebx,%edx <== NOT EXECUTED 10b42c: 75 e0 jne 10b40e <_Thread_queue_Enqueue_priority+0xd2> <== NOT EXECUTED 10b42e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b431: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10b433: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b436: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b43a: 75 44 jne 10b480 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b43c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b443: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b446: 74 1b je 10b463 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10b448: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10b44a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = search_node; 10b44c: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED search_node->next = the_node; 10b44f: 89 0a mov %ecx,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10b451: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b454: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b457: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b45a: 56 push %esi <== NOT EXECUTED 10b45b: 9d popf <== NOT EXECUTED 10b45c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b461: eb 28 jmp 10b48b <_Thread_queue_Enqueue_priority+0x14f> <== NOT EXECUTED 10b463: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b466: 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; 10b469: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b46c: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b46e: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b471: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10b473: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b476: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b479: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b47c: 53 push %ebx <== NOT EXECUTED 10b47d: 9d popf <== NOT EXECUTED 10b47e: eb dc jmp 10b45c <_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; 10b480: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b483: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10b485: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b488: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10b48b: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10b48e: 5b pop %ebx <== NOT EXECUTED 10b48f: 5e pop %esi <== NOT EXECUTED 10b490: 5f pop %edi <== NOT EXECUTED 10b491: c9 leave <== NOT EXECUTED 10b492: c3 ret <== NOT EXECUTED 0010b2b0 <_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 ) { 10b2b0: 55 push %ebp <== NOT EXECUTED 10b2b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b2b3: 57 push %edi <== NOT EXECUTED 10b2b4: 56 push %esi <== NOT EXECUTED 10b2b5: 53 push %ebx <== NOT EXECUTED 10b2b6: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10b2b9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b2bc: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10b2bf: 8b 1d 38 d7 11 00 mov 0x11d738,%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 ); 10b2c5: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10b2c8: 53 push %ebx <== NOT EXECUTED 10b2c9: e8 82 03 00 00 call 10b650 <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10b2ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2d1: 85 ff test %edi,%edi <== NOT EXECUTED 10b2d3: 74 30 je 10b305 <_Thread_queue_Enqueue_with_handler+0x55> <== NOT EXECUTED _Watchdog_Initialize( 10b2d5: 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. * 10b2d8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b2df: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b2e2: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b2e5: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10b2e8: 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, 10b2ef: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b2f2: 57 push %edi <== NOT EXECUTED 10b2f3: 57 push %edi <== NOT EXECUTED 10b2f4: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b2f7: 50 push %eax <== NOT EXECUTED 10b2f8: 68 58 d7 11 00 push $0x11d758 <== NOT EXECUTED 10b2fd: e8 fa 08 00 00 call 10bbfc <_Watchdog_Insert> <== NOT EXECUTED 10b302: 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 ) 10b305: ba 3c b3 10 00 mov $0x10b33c,%edx <== NOT EXECUTED 10b30a: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10b30e: 74 05 je 10b315 <_Thread_queue_Enqueue_with_handler+0x65> <== NOT EXECUTED 10b310: ba 10 e2 10 00 mov $0x10e210,%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 ); 10b315: 51 push %ecx <== NOT EXECUTED 10b316: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b319: 50 push %eax <== NOT EXECUTED 10b31a: 53 push %ebx <== NOT EXECUTED 10b31b: 56 push %esi <== NOT EXECUTED 10b31c: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b31e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b321: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b324: 74 0e je 10b334 <_Thread_queue_Enqueue_with_handler+0x84> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10b326: 52 push %edx <== NOT EXECUTED 10b327: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b32a: 53 push %ebx <== NOT EXECUTED 10b32b: 50 push %eax <== NOT EXECUTED 10b32c: e8 43 f6 ff ff call 10a974 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10b331: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b334: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b337: 5b pop %ebx <== NOT EXECUTED 10b338: 5e pop %esi <== NOT EXECUTED 10b339: 5f pop %edi <== NOT EXECUTED 10b33a: c9 leave <== NOT EXECUTED 10b33b: c3 ret <== NOT EXECUTED 0010e250 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e250: 55 push %ebp <== NOT EXECUTED 10e251: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e253: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e256: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e259: 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 ) 10e25c: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10e260: 75 0f jne 10e271 <_Thread_queue_Extract+0x21> <== NOT EXECUTED _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 10e262: 51 push %ecx <== NOT EXECUTED 10e263: 6a 00 push $0x0 <== NOT EXECUTED 10e265: 52 push %edx <== NOT EXECUTED 10e266: 50 push %eax <== NOT EXECUTED 10e267: e8 14 00 00 00 call 10e280 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10e26c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10e26f: c9 leave <== NOT EXECUTED 10e270: 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 ); 10e271: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10e274: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e277: 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 ); 10e278: e9 53 0d 00 00 jmp 10efd0 <_Thread_queue_Extract_fifo> <== NOT EXECUTED 0010efd0 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10efd0: 55 push %ebp <== NOT EXECUTED 10efd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10efd3: 53 push %ebx <== NOT EXECUTED 10efd4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10efd7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10efda: 9c pushf <== NOT EXECUTED 10efdb: fa cli <== NOT EXECUTED 10efdc: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10efdd: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10efe4: 75 07 jne 10efed <_Thread_queue_Extract_fifo+0x1d> <== NOT EXECUTED _ISR_Enable( level ); 10efe6: 51 push %ecx <== NOT EXECUTED 10efe7: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10efe8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10efeb: c9 leave <== NOT EXECUTED 10efec: c3 ret <== NOT EXECUTED 10efed: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10efef: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10eff2: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10eff5: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 10eff7: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10effe: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10f002: 74 04 je 10f008 <_Thread_queue_Extract_fifo+0x38> <== NOT EXECUTED _ISR_Enable( level ); 10f004: 51 push %ecx <== NOT EXECUTED 10f005: 9d popf <== NOT EXECUTED 10f006: eb 18 jmp 10f020 <_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 */ 10f008: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10f00f: 51 push %ecx <== NOT EXECUTED 10f010: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f011: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f014: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10f017: 50 push %eax <== NOT EXECUTED 10f018: e8 f7 cc ff ff call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED 10f01d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f020: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10f027: 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 } 10f02a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f02d: c9 leave <== NOT EXECUTED 10f02e: e9 ad ba ff ff jmp 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 0010e280 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 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 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e28c: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10e28f: 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 ); 10e292: 9c pushf <== NOT EXECUTED 10e293: fa cli <== NOT EXECUTED 10e294: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e297: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10e29e: 75 09 jne 10e2a9 <_Thread_queue_Extract_priority_helper+0x29> <== NOT EXECUTED _ISR_Enable( level ); 10e2a0: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10e2a3: 9d popf <== NOT EXECUTED 10e2a4: e9 8f 00 00 00 jmp 10e338 <_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; 10e2a9: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10e2ab: 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( 10e2ae: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10e2b1: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10e2b4: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10e2b6: 74 33 je 10e2eb <_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; 10e2b8: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10e2bb: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10e2be: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10e2c0: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10e2c2: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10e2c5: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10e2c7: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10e2ca: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10e2cd: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10e2d0: 74 1e je 10e2f0 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10e2d2: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10e2d5: 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; 10e2d8: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10e2db: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e2de: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10e2e1: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10e2e4: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e2e7: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e2e9: eb 05 jmp 10e2f0 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED } } else { previous_node->next = next_node; 10e2eb: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10e2ed: 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 ) { 10e2f0: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10e2f4: 74 06 je 10e2fc <_Thread_queue_Extract_priority_helper+0x7c> <== NOT EXECUTED _ISR_Enable( level ); 10e2f6: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10e2f9: 9d popf <== NOT EXECUTED 10e2fa: eb 3c jmp 10e338 <_Thread_queue_Extract_priority_helper+0xb8> <== NOT EXECUTED return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10e2fc: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10e300: 74 06 je 10e308 <_Thread_queue_Extract_priority_helper+0x88> <== NOT EXECUTED _ISR_Enable( level ); 10e302: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10e305: 9d popf <== NOT EXECUTED 10e306: eb 1a jmp 10e322 <_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 */ 10e308: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10e30f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10e312: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e313: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e316: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10e319: 50 push %eax <== NOT EXECUTED 10e31a: e8 f5 d9 ff ff call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED 10e31f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e322: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10e329: 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 } 10e32c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e32f: 5b pop %ebx <== NOT EXECUTED 10e330: 5e pop %esi <== NOT EXECUTED 10e331: 5f pop %edi <== NOT EXECUTED 10e332: c9 leave <== NOT EXECUTED 10e333: e9 a8 c7 ff ff jmp 10aae0 <_Thread_Clear_state> <== NOT EXECUTED 10e338: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e33b: 5b pop %ebx <== NOT EXECUTED 10e33c: 5e pop %esi <== NOT EXECUTED 10e33d: 5f pop %edi <== NOT EXECUTED 10e33e: c9 leave <== NOT EXECUTED 10e33f: c3 ret <== NOT EXECUTED 0010b494 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10b494: 55 push %ebp <== NOT EXECUTED 10b495: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b497: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b49a: 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 ) ) { 10b49d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b49f: f7 42 10 e0 be 03 00 testl $0x3bee0,0x10(%edx) <== NOT EXECUTED 10b4a6: 74 10 je 10b4b8 <_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 ); 10b4a8: 50 push %eax <== NOT EXECUTED 10b4a9: 50 push %eax <== NOT EXECUTED 10b4aa: 52 push %edx <== NOT EXECUTED 10b4ab: ff 72 44 pushl 0x44(%edx) <== NOT EXECUTED 10b4ae: e8 9d 2d 00 00 call 10e250 <_Thread_queue_Extract> <== NOT EXECUTED 10b4b3: b0 01 mov $0x1,%al <== NOT EXECUTED 10b4b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10b4b8: c9 leave <== NOT EXECUTED 10b4b9: c3 ret <== NOT EXECUTED 0010d1b8 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10d1b8: 55 push %ebp <== NOT EXECUTED 10d1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1bb: 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 ) 10d1be: b9 d4 d1 10 00 mov $0x10d1d4,%ecx <== NOT EXECUTED 10d1c3: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10d1c7: 74 05 je 10d1ce <_Thread_queue_First+0x16> <== NOT EXECUTED 10d1c9: b9 c4 00 11 00 mov $0x1100c4,%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 ); 10d1ce: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10d1d1: 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 ); 10d1d2: ff e1 jmp *%ecx <== NOT EXECUTED 001100c4 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 1100c4: 55 push %ebp <== NOT EXECUTED 1100c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1100c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1100ca: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 1100cd: 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 ) ) 1100cf: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1100d1: 0f 95 c2 setne %dl <== NOT EXECUTED 1100d4: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 1100d7: f7 da neg %edx <== NOT EXECUTED 1100d9: 21 d0 and %edx,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 1100db: c9 leave <== NOT EXECUTED 1100dc: c3 ret <== NOT EXECUTED 0010d1d4 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 10d1d4: 55 push %ebp <== NOT EXECUTED 10d1d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1d7: 56 push %esi <== NOT EXECUTED 10d1d8: 53 push %ebx <== NOT EXECUTED 10d1d9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10d1dc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d1de: 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( 10d1e0: 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 ] ) ) 10d1e3: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 10d1e6: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 10d1ea: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10d1ec: 74 04 je 10d1f2 <_Thread_queue_First_priority+0x1e> <== NOT EXECUTED return (Thread_Control *) 10d1ee: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d1f0: eb 0b jmp 10d1fd <_Thread_queue_First_priority+0x29> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10d1f2: 42 inc %edx <== NOT EXECUTED 10d1f3: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10d1f6: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10d1f9: 75 e5 jne 10d1e0 <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 10d1fb: 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; } 10d1fd: 5b pop %ebx <== NOT EXECUTED 10d1fe: 5e pop %esi <== NOT EXECUTED 10d1ff: c9 leave <== NOT EXECUTED 10d200: c3 ret <== NOT EXECUTED 0010b4bc <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b4bc: 55 push %ebp <== NOT EXECUTED 10b4bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4bf: 56 push %esi <== NOT EXECUTED 10b4c0: 53 push %ebx <== NOT EXECUTED 10b4c1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b4c4: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10b4c7: eb 03 jmp 10b4cc <_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; 10b4c9: 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 )) ) { 10b4cc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b4cf: 56 push %esi <== NOT EXECUTED 10b4d0: e8 c3 fc ff ff call 10b198 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b4d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b4d8: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4da: 75 ed jne 10b4c9 <_Thread_queue_Flush+0xd> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10b4dc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b4df: 5b pop %ebx <== NOT EXECUTED 10b4e0: 5e pop %esi <== NOT EXECUTED 10b4e1: c9 leave <== NOT EXECUTED 10b4e2: c3 ret <== NOT EXECUTED 0010b4e4 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10b4e4: 55 push %ebp <== NOT EXECUTED 10b4e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4e7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b4ea: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10b4ed: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b4f0: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10b4f3: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10b4f6: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b4f9: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b4fc: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10b503: 48 dec %eax <== NOT EXECUTED 10b504: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b507: 75 47 jne 10b550 <_Thread_queue_Initialize+0x6c> <== NOT EXECUTED 10b509: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b50b: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b512: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10b515: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b518: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10b51b: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10b522: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10b525: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10b528: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10b52b: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10b52e: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10b535: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10b538: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10b53b: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10b53e: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10b541: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10b548: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10b54b: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10b54e: eb 0c jmp 10b55c <_Thread_queue_Initialize+0x78> <== NOT EXECUTED 10b550: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b552: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b559: 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 ); } } 10b55c: c9 leave <== NOT EXECUTED 10b55d: c3 ret <== NOT EXECUTED 0010e340 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10e340: 55 push %ebp <== NOT EXECUTED 10e341: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e343: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e346: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10e349: 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 && 10e34c: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10e34f: 85 c0 test %eax,%eax <== NOT EXECUTED 10e351: 74 1c je 10e36f <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED 10e353: 3b 0d 38 d7 11 00 cmp 0x11d738,%ecx <== NOT EXECUTED 10e359: 75 14 jne 10e36f <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10e35b: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10e35e: 74 23 je 10e383 <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10e360: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10e363: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10e366: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) <== NOT EXECUTED 10e36d: eb 14 jmp 10e383 <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10e36f: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10e372: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10e375: 50 push %eax <== NOT EXECUTED 10e376: 50 push %eax <== NOT EXECUTED 10e377: 51 push %ecx <== NOT EXECUTED 10e378: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10e37b: e8 d0 fe ff ff call 10e250 <_Thread_queue_Extract> <== NOT EXECUTED 10e380: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10e383: c9 leave <== NOT EXECUTED 10e384: c3 ret <== NOT EXECUTED 0010b560 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10b560: 55 push %ebp <== NOT EXECUTED 10b561: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b563: 57 push %edi <== NOT EXECUTED 10b564: 56 push %esi <== NOT EXECUTED 10b565: 53 push %ebx <== NOT EXECUTED 10b566: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b569: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b56c: 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 ) 10b56f: 85 db test %ebx,%ebx <== NOT EXECUTED 10b571: 74 36 je 10b5a9 <_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 ) { 10b573: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b577: 75 30 jne 10b5a9 <_Thread_queue_Requeue+0x49> <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10b579: 9c pushf <== NOT EXECUTED 10b57a: fa cli <== NOT EXECUTED 10b57b: 5f pop %edi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10b57c: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) <== NOT EXECUTED 10b583: 74 22 je 10b5a7 <_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 10b585: 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 ); 10b58c: 50 push %eax <== NOT EXECUTED 10b58d: 6a 01 push $0x1 <== NOT EXECUTED 10b58f: 56 push %esi <== NOT EXECUTED 10b590: 53 push %ebx <== NOT EXECUTED 10b591: e8 ea 2c 00 00 call 10e280 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10b596: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b599: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b59c: 50 push %eax <== NOT EXECUTED 10b59d: 56 push %esi <== NOT EXECUTED 10b59e: 53 push %ebx <== NOT EXECUTED 10b59f: e8 98 fd ff ff call 10b33c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10b5a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 10b5a7: 57 push %edi <== NOT EXECUTED 10b5a8: 9d popf <== NOT EXECUTED } } 10b5a9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b5ac: 5b pop %ebx <== NOT EXECUTED 10b5ad: 5e pop %esi <== NOT EXECUTED 10b5ae: 5f pop %edi <== NOT EXECUTED 10b5af: c9 leave <== NOT EXECUTED 10b5b0: c3 ret <== NOT EXECUTED 0010b5b4 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10b5b4: 55 push %ebp <== NOT EXECUTED 10b5b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5b7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b5ba: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b5bd: 50 push %eax <== NOT EXECUTED 10b5be: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b5c1: e8 ba f8 ff ff call 10ae80 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b5c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5c9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b5cd: 75 17 jne 10b5e6 <_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 ); 10b5cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5d2: 50 push %eax <== NOT EXECUTED 10b5d3: e8 68 2d 00 00 call 10e340 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10b5d8: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 10b5dd: 48 dec %eax <== NOT EXECUTED 10b5de: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED 10b5e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10b5e6: c9 leave <== NOT EXECUTED 10b5e7: c3 ret <== NOT EXECUTED 0010d9c8 <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10d9c8: 55 push %ebp <== NOT EXECUTED 10d9c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d9cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d9ce: 6a 04 push $0x4 <== NOT EXECUTED 10d9d0: 6a 00 push $0x0 <== NOT EXECUTED 10d9d2: 6a 3c push $0x3c <== NOT EXECUTED 10d9d4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9d7: 6a 02 push $0x2 <== NOT EXECUTED 10d9d9: 6a 02 push $0x2 <== NOT EXECUTED 10d9db: 68 38 e1 11 00 push $0x11e138 <== NOT EXECUTED 10d9e0: e8 13 cd ff ff call 10a6f8 <_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; 10d9e5: c7 05 7c e1 11 00 00 movl $0x0,0x11e17c <== NOT EXECUTED 10d9ec: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10d9ef: c7 05 78 e1 11 00 00 movl $0x0,0x11e178 <== NOT EXECUTED 10d9f6: 00 00 00 <== NOT EXECUTED 10d9f9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10d9fc: c9 leave <== NOT EXECUTED 10d9fd: 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 88 41 13 00 mov 0x134188,%eax <== NOT EXECUTED 113238: a3 bc 3f 13 00 mov %eax,0x133fbc <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 11323d: a1 c8 40 13 00 mov 0x1340c8,%eax <== NOT EXECUTED 113242: a3 b8 3f 13 00 mov %eax,0x133fb8 <== 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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 11324c: 40 inc %eax <== NOT EXECUTED 11324d: a3 38 40 13 00 mov %eax,0x134038 <== 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 30 25 00 00 call 11578c <_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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 113263: 40 inc %eax <== NOT EXECUTED 113264: a3 38 40 13 00 mov %eax,0x134038 <== 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 bc 49 13 00 pushl 0x1349bc <== NOT EXECUTED 113273: e8 30 2e 00 00 call 1160a8 <_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 ac 3f 13 00 mov 0x133fac,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 11327e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113281: 81 fa b0 3f 13 00 cmp $0x133fb0,%edx <== NOT EXECUTED 113287: 74 1e je 1132a7 <_Timer_Server_body+0x93> <== NOT EXECUTED 113289: a1 bc 49 13 00 mov 0x1349bc,%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 18 41 13 00 push $0x134118 <== NOT EXECUTED 11329f: e8 04 36 00 00 call 1168a8 <_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 c0 3f 13 00 mov 0x133fc0,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 1132ac: 3d c4 3f 13 00 cmp $0x133fc4,%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 e4 3f 13 00 mov %eax,0x133fe4 <== NOT EXECUTED size_t size ); 1132bb: 50 push %eax <== NOT EXECUTED 1132bc: 50 push %eax <== NOT EXECUTED 1132bd: 68 d8 3f 13 00 push $0x133fd8 <== NOT EXECUTED 1132c2: 68 0c 41 13 00 push $0x13410c <== NOT EXECUTED 1132c7: e8 dc 35 00 00 call 1168a8 <_Watchdog_Insert> <== NOT EXECUTED 1132cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 1132cf: e8 b8 24 00 00 call 11578c <_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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 1132d9: 40 inc %eax <== NOT EXECUTED 1132da: a3 38 40 13 00 mov %eax,0x134038 <== 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 bc 49 13 00 mov 0x1349bc,%eax <== NOT EXECUTED 1132e7: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1132ea: 50 push %eax <== NOT EXECUTED 1132eb: e8 d0 36 00 00 call 1169c0 <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 1132f0: c7 04 24 d8 3f 13 00 movl $0x133fd8,(%esp) <== NOT EXECUTED 1132f7: e8 c4 36 00 00 call 1169c0 <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 1132fc: 8b 15 88 41 13 00 mov 0x134188,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 113302: a1 bc 3f 13 00 mov 0x133fbc,%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 bc 3f 13 00 mov %edx,0x133fbc <== 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 ac 3f 13 00 push $0x133fac <== NOT EXECUTED 113328: e8 eb 34 00 00 call 116818 <_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 c8 40 13 00 mov 0x1340c8,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 113333: a1 b8 3f 13 00 mov 0x133fb8,%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 c0 3f 13 00 push $0x133fc0 <== NOT EXECUTED 11334b: e8 c8 34 00 00 call 116818 <_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 c0 3f 13 00 push $0x133fc0 <== NOT EXECUTED 11335f: e8 48 34 00 00 call 1167ac <_Watchdog_Adjust> <== NOT EXECUTED 113364: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Timer_Server_seconds_last_time = snapshot; 113367: 89 1d b8 3f 13 00 mov %ebx,0x133fb8 <== 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 15 24 00 00 call 11578c <_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 cc 3f 13 00 push $0x133fcc <== NOT EXECUTED 1131d2: e8 a5 08 00 00 call 113a7c <_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 ac 3f 13 00 push $0x133fac <== 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 c0 3f 13 00 push $0x133fc0 <== NOT EXECUTED 113203: e8 a0 36 00 00 call 1168a8 <_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 cc 3f 13 00 push $0x133fcc <== NOT EXECUTED 113199: e8 ba 08 00 00 call 113a58 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 11319e: a1 bc 49 13 00 mov 0x1349bc,%eax <== NOT EXECUTED 1131a3: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1131a6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1131a9: e8 12 38 00 00 call 1169c0 <_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 bc 49 13 00 mov 0x1349bc,%eax <== NOT EXECUTED 1131b7: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1131ba: e8 51 24 00 00 call 115610 <_Thread_Delay_ended> <== NOT EXECUTED 1131bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1131c2: c9 leave <== NOT EXECUTED 1131c3: c3 ret <== NOT EXECUTED 0010b988 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10b988: 55 push %ebp <== NOT EXECUTED 10b989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b98b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b98e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10b991: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10b993: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10b995: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b998: 01 42 04 add %eax,0x4(%edx) <== NOT EXECUTED 10b99b: eb 0b jmp 10b9a8 <_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; 10b99d: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10b9a2: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10b9a5: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10b9a7: 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 ) { 10b9a8: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b9ab: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10b9b0: 77 eb ja 10b99d <_Timespec_Add_to+0x15> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10b9b2: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b9b4: c9 leave <== NOT EXECUTED 10b9b5: c3 ret <== NOT EXECUTED 0010ced8 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10ced8: 55 push %ebp <== NOT EXECUTED 10ced9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cedb: 57 push %edi <== NOT EXECUTED 10cedc: 56 push %esi <== NOT EXECUTED 10cedd: 53 push %ebx <== NOT EXECUTED 10cede: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cee1: 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; 10cee4: 8b 18 mov (%eax),%ebx <== NOT EXECUTED left += lhs->tv_nsec; 10cee6: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cee9: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ceec: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10cef1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10cef4: f7 29 imull (%ecx) <== NOT EXECUTED 10cef6: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cef8: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10cefa: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10cefd: 99 cltd <== NOT EXECUTED 10cefe: 01 c6 add %eax,%esi <== NOT EXECUTED 10cf00: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10cf02: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cf04: 09 f0 or %esi,%eax <== NOT EXECUTED 10cf06: 75 14 jne 10cf1c <_Timespec_Divide+0x44> <== NOT EXECUTED *ival_percentage = 0; 10cf08: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10cf0b: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10cf11: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10cf14: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 10cf1a: eb 70 jmp 10cf8c <_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; 10cf1c: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10cf21: f7 eb imul %ebx <== NOT EXECUTED 10cf23: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10cf26: 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; 10cf29: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10cf2c: 99 cltd <== NOT EXECUTED 10cf2d: 01 45 e8 add %eax,-0x18(%ebp) <== NOT EXECUTED 10cf30: 11 55 ec adc %edx,-0x14(%ebp) <== NOT EXECUTED 10cf33: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx <== NOT EXECUTED 10cf3a: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10cf3f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10cf42: f7 e1 mul %ecx <== NOT EXECUTED 10cf44: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10cf47: 01 da add %ebx,%edx <== NOT EXECUTED 10cf49: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 10cf4c: 57 push %edi <== NOT EXECUTED 10cf4d: 56 push %esi <== NOT EXECUTED 10cf4e: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10cf51: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 10cf54: e8 ff ad 00 00 call 117d58 <__udivdi3> <== NOT EXECUTED 10cf59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf5c: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10cf5e: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10cf60: 6a 00 push $0x0 <== NOT EXECUTED 10cf62: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cf67: 52 push %edx <== NOT EXECUTED 10cf68: 50 push %eax <== NOT EXECUTED 10cf69: e8 ea ad 00 00 call 117d58 <__udivdi3> <== NOT EXECUTED 10cf6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf71: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10cf74: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10cf76: 6a 00 push $0x0 <== NOT EXECUTED 10cf78: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cf7d: 56 push %esi <== NOT EXECUTED 10cf7e: 53 push %ebx <== NOT EXECUTED 10cf7f: e8 e0 ae 00 00 call 117e64 <__umoddi3> <== NOT EXECUTED 10cf84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf87: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10cf8a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED } 10cf8c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cf8f: 5b pop %ebx <== NOT EXECUTED 10cf90: 5e pop %esi <== NOT EXECUTED 10cf91: 5f pop %edi <== NOT EXECUTED 10cf92: c9 leave <== NOT EXECUTED 10cf93: c3 ret <== NOT EXECUTED 00122888 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 122888: 55 push %ebp <== NOT EXECUTED 122889: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12288b: 57 push %edi <== NOT EXECUTED 12288c: 56 push %esi <== NOT EXECUTED 12288d: 53 push %ebx <== NOT EXECUTED 12288e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122891: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 122894: 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; 122897: 8b 06 mov (%esi),%eax <== NOT EXECUTED 122899: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 12289a: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 1228a0: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 1228a5: f7 e1 mul %ecx <== NOT EXECUTED 1228a7: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 1228aa: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 1228ad: 89 cb mov %ecx,%ebx <== NOT EXECUTED 1228af: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 1228b2: 01 c8 add %ecx,%eax <== NOT EXECUTED 1228b4: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 1228b6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1228b9: 31 db xor %ebx,%ebx <== NOT EXECUTED 1228bb: 53 push %ebx <== NOT EXECUTED 1228bc: 51 push %ecx <== NOT EXECUTED 1228bd: 52 push %edx <== NOT EXECUTED 1228be: 50 push %eax <== NOT EXECUTED 1228bf: e8 b8 69 01 00 call 13927c <__udivdi3> <== NOT EXECUTED 1228c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1228c7: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1228c9: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 1228cb: 6a 00 push $0x0 <== NOT EXECUTED 1228cd: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 1228d2: 52 push %edx <== NOT EXECUTED 1228d3: 50 push %eax <== NOT EXECUTED 1228d4: e8 a3 69 01 00 call 13927c <__udivdi3> <== NOT EXECUTED 1228d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1228dc: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 1228de: 6a 00 push $0x0 <== NOT EXECUTED 1228e0: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 1228e5: 56 push %esi <== NOT EXECUTED 1228e6: 53 push %ebx <== NOT EXECUTED 1228e7: e8 9c 6a 01 00 call 139388 <__umoddi3> <== NOT EXECUTED 1228ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1228ef: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 1228f2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1228f5: 5b pop %ebx <== NOT EXECUTED 1228f6: 5e pop %esi <== NOT EXECUTED 1228f7: 5f pop %edi <== NOT EXECUTED 1228f8: c9 leave <== NOT EXECUTED 1228f9: c3 ret <== NOT EXECUTED 00113a30 <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 113a30: 55 push %ebp <== NOT EXECUTED 113a31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a33: 56 push %esi <== NOT EXECUTED 113a34: 53 push %ebx <== NOT EXECUTED 113a35: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 113a38: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 113a3b: 0f af 1d f8 9a 12 00 imul 0x129af8,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 113a42: be 40 42 0f 00 mov $0xf4240,%esi <== NOT EXECUTED 113a47: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113a49: 31 d2 xor %edx,%edx <== NOT EXECUTED 113a4b: f7 f6 div %esi <== NOT EXECUTED 113a4d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 113a4f: 69 c2 e8 03 00 00 imul $0x3e8,%edx,%eax <== NOT EXECUTED 113a55: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 113a58: 5b pop %ebx <== NOT EXECUTED 113a59: 5e pop %esi <== NOT EXECUTED 113a5a: c9 leave <== NOT EXECUTED 113a5b: c3 ret <== NOT EXECUTED 0010d324 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10d324: 55 push %ebp <== NOT EXECUTED 10d325: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d327: 53 push %ebx <== NOT EXECUTED 10d328: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d32b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10d32e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d330: b2 01 mov $0x1,%dl <== NOT EXECUTED 10d332: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10d334: 7f 0f jg 10d345 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10d336: 7d 04 jge 10d33c <_Timespec_Greater_than+0x18> <== NOT EXECUTED 10d338: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d33a: eb 09 jmp 10d345 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10d33c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d33f: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10d342: 0f 9f c2 setg %dl <== NOT EXECUTED return TRUE; return FALSE; } 10d345: 88 d0 mov %dl,%al <== NOT EXECUTED 10d347: 5b pop %ebx <== NOT EXECUTED 10d348: c9 leave <== NOT EXECUTED 10d349: c3 ret <== NOT EXECUTED 00113a5c <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 113a5c: 55 push %ebp <== NOT EXECUTED 113a5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a5f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 113a62: 85 c0 test %eax,%eax <== NOT EXECUTED 113a64: 74 16 je 113a7c <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 113a66: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 113a69: 78 11 js 113a7c <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 113a6b: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 113a6e: 85 c0 test %eax,%eax <== NOT EXECUTED 113a70: 78 0a js 113a7c <_Timespec_Is_valid+0x20> <== NOT EXECUTED 113a72: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 113a77: 0f 96 c0 setbe %al <== NOT EXECUTED 113a7a: eb 02 jmp 113a7e <_Timespec_Is_valid+0x22> <== NOT EXECUTED 113a7c: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 113a7e: c9 leave <== NOT EXECUTED 113a7f: c3 ret <== NOT EXECUTED 0010e478 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10e478: 55 push %ebp <== NOT EXECUTED 10e479: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e47b: 53 push %ebx <== NOT EXECUTED 10e47c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e47f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10e482: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e484: b2 01 mov $0x1,%dl <== NOT EXECUTED 10e486: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10e488: 7c 0f jl 10e499 <_Timespec_Less_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10e48a: 7e 04 jle 10e490 <_Timespec_Less_than+0x18> <== NOT EXECUTED 10e48c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e48e: eb 09 jmp 10e499 <_Timespec_Less_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10e490: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e493: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10e496: 0f 9c c2 setl %dl <== NOT EXECUTED return TRUE; return FALSE; } 10e499: 88 d0 mov %dl,%al <== NOT EXECUTED 10e49b: 5b pop %ebx <== NOT EXECUTED 10e49c: c9 leave <== NOT EXECUTED 10e49d: c3 ret <== NOT EXECUTED 0010b9b8 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10b9b8: 55 push %ebp <== NOT EXECUTED 10b9b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9bb: 53 push %ebx <== NOT EXECUTED 10b9bc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b9bf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b9c2: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10b9c5: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10b9c8: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10b9cb: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10b9cd: 7d 13 jge 10b9e2 <_Timespec_Subtract+0x2a> <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 10b9cf: 48 dec %eax <== NOT EXECUTED 10b9d0: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b9d2: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10b9d4: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10b9da: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10b9dd: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10b9e0: eb 0a jmp 10b9ec <_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; 10b9e2: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b9e4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10b9e6: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10b9e9: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10b9ec: 5b pop %ebx <== NOT EXECUTED 10b9ed: c9 leave <== NOT EXECUTED 10b9ee: c3 ret <== NOT EXECUTED 0010e480 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 10e480: 55 push %ebp <== NOT EXECUTED 10e481: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e483: 57 push %edi <== NOT EXECUTED 10e484: 56 push %esi <== NOT EXECUTED 10e485: 53 push %ebx <== NOT EXECUTED 10e486: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e489: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 10e48c: 8b 31 mov (%ecx),%esi <== NOT EXECUTED 10e48e: 85 f6 test %esi,%esi <== NOT EXECUTED 10e490: 75 08 jne 10e49a <_Timespec_To_ticks+0x1a> <== NOT EXECUTED 10e492: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e494: 83 79 04 00 cmpl $0x0,0x4(%ecx) <== NOT EXECUTED 10e498: 74 2f je 10e4c9 <_Timespec_To_ticks+0x49> <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 10e49a: 8b 1d 14 d8 11 00 mov 0x11d814,%ebx <== NOT EXECUTED 10e4a0: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 10e4a5: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e4a7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e4a9: f7 f3 div %ebx <== NOT EXECUTED 10e4ab: 89 c7 mov %eax,%edi <== NOT EXECUTED 10e4ad: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 10e4b0: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e4b3: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 10e4b8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e4ba: f7 f1 div %ecx <== NOT EXECUTED 10e4bc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e4be: f7 f3 div %ebx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 10e4c0: 01 f8 add %edi,%eax <== NOT EXECUTED 10e4c2: 75 05 jne 10e4c9 <_Timespec_To_ticks+0x49> <== NOT EXECUTED 10e4c4: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 10e4c9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e4cc: 5b pop %ebx <== NOT EXECUTED 10e4cd: 5e pop %esi <== NOT EXECUTED 10e4ce: 5f pop %edi <== NOT EXECUTED 10e4cf: c9 leave <== NOT EXECUTED 10e4d0: c3 ret <== NOT EXECUTED 0010e4d4 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10e4d4: 55 push %ebp <== NOT EXECUTED 10e4d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e4d7: 53 push %ebx <== NOT EXECUTED 10e4d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4db: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10e4de: 53 push %ebx <== NOT EXECUTED 10e4df: 68 90 d8 11 00 push $0x11d890 <== NOT EXECUTED 10e4e4: e8 d7 b5 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10e4e9: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10e4ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e4ef: 85 c0 test %eax,%eax <== NOT EXECUTED 10e4f1: 74 16 je 10e509 <_User_extensions_Add_API_set+0x35> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10e4f3: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10e4f6: 50 push %eax <== NOT EXECUTED 10e4f7: 50 push %eax <== NOT EXECUTED 10e4f8: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10e4fb: 50 push %eax <== NOT EXECUTED 10e4fc: 68 7c d6 11 00 push $0x11d67c <== NOT EXECUTED 10e501: e8 ba b5 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED 10e506: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10e509: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e50c: c9 leave <== NOT EXECUTED 10e50d: c3 ret <== NOT EXECUTED 0010e510 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10e510: 55 push %ebp <== NOT EXECUTED 10e511: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e513: 57 push %edi <== NOT EXECUTED 10e514: 56 push %esi <== NOT EXECUTED 10e515: 53 push %ebx <== NOT EXECUTED 10e516: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10e519: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e51c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e51f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10e522: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10e525: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10e52a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e52c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10e52e: 53 push %ebx <== NOT EXECUTED 10e52f: 68 90 d8 11 00 push $0x11d890 <== NOT EXECUTED 10e534: e8 87 b5 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10e539: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10e53c: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10e53f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e542: 85 c0 test %eax,%eax <== NOT EXECUTED 10e544: 74 1c je 10e562 <_User_extensions_Add_set+0x52> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10e546: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10e549: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10e54c: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10e54f: c7 45 08 7c d6 11 00 movl $0x11d67c,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10e556: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e559: 5b pop %ebx <== NOT EXECUTED 10e55a: 5e pop %esi <== NOT EXECUTED 10e55b: 5f pop %edi <== NOT EXECUTED 10e55c: 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( 10e55d: e9 5e b5 ff ff jmp 109ac0 <_Chain_Append> <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10e562: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e565: 5b pop %ebx <== NOT EXECUTED 10e566: 5e pop %esi <== NOT EXECUTED 10e567: 5f pop %edi <== NOT EXECUTED 10e568: c9 leave <== NOT EXECUTED 10e569: c3 ret <== NOT EXECUTED 0010badf <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10badf: 55 push %ebp <== NOT EXECUTED 10bae0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bae2: 57 push %edi <== NOT EXECUTED 10bae3: 56 push %esi <== NOT EXECUTED 10bae4: 53 push %ebx <== NOT EXECUTED 10bae5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bae8: 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 ; 10baeb: 8b 1d 98 d8 11 00 mov 0x11d898,%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 ); 10baf1: 0f b6 75 0c movzbl 0xc(%ebp),%esi <== NOT EXECUTED 10baf5: eb 15 jmp 10bb0c <_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 ) 10baf7: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10bafa: 85 c0 test %eax,%eax <== NOT EXECUTED 10bafc: 74 0b je 10bb09 <_User_extensions_Fatal+0x2a> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10bafe: 52 push %edx <== NOT EXECUTED 10baff: 57 push %edi <== NOT EXECUTED 10bb00: 56 push %esi <== NOT EXECUTED 10bb01: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bb04: ff d0 call *%eax <== NOT EXECUTED 10bb06: 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 ) { 10bb09: 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 ) ; 10bb0c: 81 fb 90 d8 11 00 cmp $0x11d890,%ebx <== NOT EXECUTED 10bb12: 75 e3 jne 10baf7 <_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 ); } } 10bb14: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bb17: 5b pop %ebx <== NOT EXECUTED 10bb18: 5e pop %esi <== NOT EXECUTED 10bb19: 5f pop %edi <== NOT EXECUTED 10bb1a: c9 leave <== NOT EXECUTED 10bb1b: c3 ret <== NOT EXECUTED 0010b9f0 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10b9f0: 55 push %ebp <== NOT EXECUTED 10b9f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9f3: 57 push %edi <== NOT EXECUTED 10b9f4: 56 push %esi <== NOT EXECUTED 10b9f5: 53 push %ebx <== NOT EXECUTED 10b9f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9f9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b9fc: c7 05 90 d8 11 00 94 movl $0x11d894,0x11d890 <== NOT EXECUTED 10ba03: d8 11 00 <== NOT EXECUTED 10ba06: c7 05 94 d8 11 00 00 movl $0x0,0x11d894 <== NOT EXECUTED 10ba0d: 00 00 00 <== NOT EXECUTED 10ba10: c7 05 98 d8 11 00 90 movl $0x11d890,0x11d898 <== NOT EXECUTED 10ba17: d8 11 00 <== NOT EXECUTED 10ba1a: c7 05 7c d6 11 00 80 movl $0x11d680,0x11d67c <== NOT EXECUTED 10ba21: d6 11 00 <== NOT EXECUTED 10ba24: c7 05 80 d6 11 00 00 movl $0x0,0x11d680 <== NOT EXECUTED 10ba2b: 00 00 00 <== NOT EXECUTED 10ba2e: c7 05 84 d6 11 00 7c movl $0x11d67c,0x11d684 <== NOT EXECUTED 10ba35: d6 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10ba38: 85 f6 test %esi,%esi <== NOT EXECUTED 10ba3a: 74 38 je 10ba74 <_User_extensions_Handler_initialization+0x84> <== NOT EXECUTED extension = (User_extensions_Control *) 10ba3c: 6b 5d 08 34 imul $0x34,0x8(%ebp),%ebx <== NOT EXECUTED 10ba40: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba43: 53 push %ebx <== NOT EXECUTED 10ba44: e8 c9 03 00 00 call 10be12 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10ba49: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10ba4c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ba4e: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10ba51: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10ba53: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10ba55: 31 db xor %ebx,%ebx <== NOT EXECUTED 10ba57: eb 13 jmp 10ba6c <_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]); 10ba59: 50 push %eax <== NOT EXECUTED 10ba5a: 50 push %eax <== NOT EXECUTED 10ba5b: 56 push %esi <== NOT EXECUTED 10ba5c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10ba5f: e8 ac 2a 00 00 call 10e510 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10ba64: 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++ ) { 10ba68: 43 inc %ebx <== NOT EXECUTED 10ba69: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10ba6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ba6f: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10ba72: 72 e5 jb 10ba59 <_User_extensions_Handler_initialization+0x69> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 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 0010f16c <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10f16c: 55 push %ebp <== NOT EXECUTED 10f16d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f16f: 53 push %ebx <== NOT EXECUTED 10f170: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f173: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 10f176: 53 push %ebx <== NOT EXECUTED 10f177: e8 e4 3d 00 00 call 112f60 <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10f17c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f17f: 83 7b 24 00 cmpl $0x0,0x24(%ebx) <== NOT EXECUTED 10f183: 74 0f je 10f194 <_User_extensions_Remove_set+0x28> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 10f185: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f188: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f18b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f18e: 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 ); 10f18f: e9 cc 3d 00 00 jmp 112f60 <_Chain_Extract> <== NOT EXECUTED } 10f194: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f197: c9 leave <== NOT EXECUTED 10f198: c3 ret <== NOT EXECUTED 0010ba7c <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 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; for ( the_node = _User_extensions_List.first ; 10ba84: 8b 1d 90 d8 11 00 mov 0x11d890,%ebx <== NOT EXECUTED 10ba8a: eb 12 jmp 10ba9e <_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 ) 10ba8c: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10ba8f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba91: 74 09 je 10ba9c <_User_extensions_Thread_begin+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10ba93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba96: 56 push %esi <== NOT EXECUTED 10ba97: ff d0 call *%eax <== NOT EXECUTED 10ba99: 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 ) { 10ba9c: 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 ) ; 10ba9e: 81 fb 94 d8 11 00 cmp $0x11d894,%ebx <== NOT EXECUTED 10baa4: 75 e6 jne 10ba8c <_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 ); } } 10baa6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10baa9: 5b pop %ebx <== NOT EXECUTED 10baaa: 5e pop %esi <== NOT EXECUTED 10baab: c9 leave <== NOT EXECUTED 10baac: c3 ret <== NOT EXECUTED 0010bb1c <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10bb1c: 55 push %ebp <== NOT EXECUTED 10bb1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb1f: 56 push %esi <== NOT EXECUTED 10bb20: 53 push %ebx <== NOT EXECUTED 10bb21: 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 ; 10bb24: 8b 1d 90 d8 11 00 mov 0x11d890,%ebx <== NOT EXECUTED 10bb2a: eb 1b jmp 10bb47 <_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 ) { 10bb2c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10bb2f: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb31: 74 12 je 10bb45 <_User_extensions_Thread_create+0x29> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10bb33: 52 push %edx <== NOT EXECUTED 10bb34: 52 push %edx <== NOT EXECUTED 10bb35: 56 push %esi <== NOT EXECUTED 10bb36: ff 35 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 10bb3c: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10bb3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bb41: 84 c0 test %al,%al <== NOT EXECUTED 10bb43: 74 0c je 10bb51 <_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 ) { 10bb45: 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 ) ; 10bb47: 81 fb 94 d8 11 00 cmp $0x11d894,%ebx <== NOT EXECUTED 10bb4d: 75 dd jne 10bb2c <_User_extensions_Thread_create+0x10> <== NOT EXECUTED 10bb4f: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10bb51: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bb54: 5b pop %ebx <== NOT EXECUTED 10bb55: 5e pop %esi <== NOT EXECUTED 10bb56: c9 leave <== NOT EXECUTED 10bb57: c3 ret <== NOT EXECUTED 0010bb58 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10bb58: 55 push %ebp <== NOT EXECUTED 10bb59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb5b: 56 push %esi <== NOT EXECUTED 10bb5c: 53 push %ebx <== NOT EXECUTED 10bb5d: 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 ; 10bb60: 8b 1d 98 d8 11 00 mov 0x11d898,%ebx <== NOT EXECUTED 10bb66: eb 18 jmp 10bb80 <_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 ) 10bb68: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10bb6b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb6d: 74 0e je 10bb7d <_User_extensions_Thread_delete+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10bb6f: 52 push %edx <== NOT EXECUTED 10bb70: 52 push %edx <== NOT EXECUTED 10bb71: 56 push %esi <== NOT EXECUTED 10bb72: ff 35 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 10bb78: ff d0 call *%eax <== NOT EXECUTED 10bb7a: 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 ) { 10bb7d: 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 ) ; 10bb80: 81 fb 90 d8 11 00 cmp $0x11d890,%ebx <== NOT EXECUTED 10bb86: 75 e0 jne 10bb68 <_User_extensions_Thread_delete+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10bb88: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bb8b: 5b pop %ebx <== NOT EXECUTED 10bb8c: 5e pop %esi <== NOT EXECUTED 10bb8d: c9 leave <== NOT EXECUTED 10bb8e: c3 ret <== NOT EXECUTED 0010baad <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10baad: 55 push %ebp <== NOT EXECUTED 10baae: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bab0: 56 push %esi <== NOT EXECUTED 10bab1: 53 push %ebx <== NOT EXECUTED 10bab2: 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 ; 10bab5: 8b 1d 98 d8 11 00 mov 0x11d898,%ebx <== NOT EXECUTED 10babb: eb 13 jmp 10bad0 <_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 ) 10babd: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10bac0: 85 c0 test %eax,%eax <== NOT EXECUTED 10bac2: 74 09 je 10bacd <_User_extensions_Thread_exitted+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10bac4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bac7: 56 push %esi <== NOT EXECUTED 10bac8: ff d0 call *%eax <== NOT EXECUTED 10baca: 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 ) { 10bacd: 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 ) ; 10bad0: 81 fb 90 d8 11 00 cmp $0x11d890,%ebx <== NOT EXECUTED 10bad6: 75 e5 jne 10babd <_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 ); } } 10bad8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10badb: 5b pop %ebx <== NOT EXECUTED 10badc: 5e pop %esi <== NOT EXECUTED 10badd: c9 leave <== NOT EXECUTED 10bade: c3 ret <== NOT EXECUTED 0010c5b4 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10c5b4: 55 push %ebp <== NOT EXECUTED 10c5b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5b7: 56 push %esi <== NOT EXECUTED 10c5b8: 53 push %ebx <== NOT EXECUTED 10c5b9: 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 ; 10c5bc: 8b 1d dc 0c 12 00 mov 0x120cdc,%ebx <== NOT EXECUTED 10c5c2: eb 17 jmp 10c5db <_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 ) 10c5c4: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10c5c7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c5c9: 74 0e je 10c5d9 <_User_extensions_Thread_restart+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10c5cb: 52 push %edx <== NOT EXECUTED 10c5cc: 52 push %edx <== NOT EXECUTED 10c5cd: 56 push %esi <== NOT EXECUTED 10c5ce: ff 35 84 0b 12 00 pushl 0x120b84 <== NOT EXECUTED 10c5d4: ff d0 call *%eax <== NOT EXECUTED 10c5d6: 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 ) { 10c5d9: 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 ) ; 10c5db: 81 fb e0 0c 12 00 cmp $0x120ce0,%ebx <== NOT EXECUTED 10c5e1: 75 e1 jne 10c5c4 <_User_extensions_Thread_restart+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10c5e3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c5e6: 5b pop %ebx <== NOT EXECUTED 10c5e7: 5e pop %esi <== NOT EXECUTED 10c5e8: c9 leave <== NOT EXECUTED 10c5e9: c3 ret <== NOT EXECUTED 0010bb90 <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10bb90: 55 push %ebp <== NOT EXECUTED 10bb91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb93: 56 push %esi <== NOT EXECUTED 10bb94: 53 push %ebx <== NOT EXECUTED 10bb95: 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 ; 10bb98: 8b 1d 90 d8 11 00 mov 0x11d890,%ebx <== NOT EXECUTED 10bb9e: eb 17 jmp 10bbb7 <_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 ) 10bba0: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10bba3: 85 c0 test %eax,%eax <== NOT EXECUTED 10bba5: 74 0e je 10bbb5 <_User_extensions_Thread_start+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10bba7: 52 push %edx <== NOT EXECUTED 10bba8: 52 push %edx <== NOT EXECUTED 10bba9: 56 push %esi <== NOT EXECUTED 10bbaa: ff 35 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 10bbb0: ff d0 call *%eax <== NOT EXECUTED 10bbb2: 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 ) { 10bbb5: 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 ) ; 10bbb7: 81 fb 94 d8 11 00 cmp $0x11d894,%ebx <== NOT EXECUTED 10bbbd: 75 e1 jne 10bba0 <_User_extensions_Thread_start+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10bbbf: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bbc2: 5b pop %ebx <== NOT EXECUTED 10bbc3: 5e pop %esi <== NOT EXECUTED 10bbc4: c9 leave <== NOT EXECUTED 10bbc5: c3 ret <== NOT EXECUTED 0010bbc8 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10bbc8: 55 push %ebp <== NOT EXECUTED 10bbc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbcb: 57 push %edi <== NOT EXECUTED 10bbcc: 56 push %esi <== NOT EXECUTED 10bbcd: 53 push %ebx <== NOT EXECUTED 10bbce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bbd1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bbd4: 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 ; 10bbd7: 8b 1d 7c d6 11 00 mov 0x11d67c,%ebx <== NOT EXECUTED 10bbdd: eb 0c jmp 10bbeb <_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 ); 10bbdf: 50 push %eax <== NOT EXECUTED 10bbe0: 50 push %eax <== NOT EXECUTED 10bbe1: 56 push %esi <== NOT EXECUTED 10bbe2: 57 push %edi <== NOT EXECUTED 10bbe3: 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 ) { 10bbe6: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bbe8: 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 ) ; 10bbeb: 81 fb 80 d6 11 00 cmp $0x11d680,%ebx <== NOT EXECUTED 10bbf1: 75 ec jne 10bbdf <_User_extensions_Thread_switch+0x17> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10bbf3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bbf6: 5b pop %ebx <== NOT EXECUTED 10bbf7: 5e pop %esi <== NOT EXECUTED 10bbf8: 5f pop %edi <== NOT EXECUTED 10bbf9: c9 leave <== NOT EXECUTED 10bbfa: c3 ret <== NOT EXECUTED 0010d234 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10d234: 55 push %ebp <== NOT EXECUTED 10d235: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d237: 57 push %edi <== NOT EXECUTED 10d238: 56 push %esi <== NOT EXECUTED 10d239: 53 push %ebx <== NOT EXECUTED 10d23a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d23d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d240: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d243: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10d246: 9c pushf <== NOT EXECUTED 10d247: fa cli <== NOT EXECUTED 10d248: 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( 10d249: 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 10d24b: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10d24e: 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 ) ) { 10d251: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10d253: 74 41 je 10d296 <_Watchdog_Adjust+0x62> <== NOT EXECUTED switch ( direction ) { 10d255: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d257: 74 39 je 10d292 <_Watchdog_Adjust+0x5e> <== NOT EXECUTED 10d259: 49 dec %ecx <== NOT EXECUTED 10d25a: 75 3a jne 10d296 <_Watchdog_Adjust+0x62> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10d25c: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10d25f: eb 35 jmp 10d296 <_Watchdog_Adjust+0x62> <== NOT EXECUTED 10d261: 8b 07 mov (%edi),%eax <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10d263: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10d266: 39 de cmp %ebx,%esi <== NOT EXECUTED 10d268: 73 07 jae 10d271 <_Watchdog_Adjust+0x3d> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 10d26a: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10d26c: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10d26f: eb 25 jmp 10d296 <_Watchdog_Adjust+0x62> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10d271: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10d278: 52 push %edx <== NOT EXECUTED 10d279: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10d27a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d27d: 57 push %edi <== NOT EXECUTED 10d27e: e8 9d 01 00 00 call 10d420 <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10d283: 9c pushf <== NOT EXECUTED 10d284: fa cli <== NOT EXECUTED 10d285: 5a pop %edx <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d289: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d28c: 39 07 cmp %eax,(%edi) <== NOT EXECUTED 10d28e: 74 06 je 10d296 <_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; 10d290: 29 de sub %ebx,%esi <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10d292: 85 f6 test %esi,%esi <== NOT EXECUTED 10d294: 75 cb jne 10d261 <_Watchdog_Adjust+0x2d> <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10d296: 52 push %edx <== NOT EXECUTED 10d297: 9d popf <== NOT EXECUTED } 10d298: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d29b: 5b pop %ebx <== NOT EXECUTED 10d29c: 5e pop %esi <== NOT EXECUTED 10d29d: 5f pop %edi <== NOT EXECUTED 10d29e: c9 leave <== NOT EXECUTED 10d29f: c3 ret <== NOT EXECUTED 00116818 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 116818: 55 push %ebp <== NOT EXECUTED 116819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11681b: 57 push %edi <== NOT EXECUTED 11681c: 56 push %esi <== NOT EXECUTED 11681d: 53 push %ebx <== NOT EXECUTED 11681e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116821: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 116824: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 116827: 85 c0 test %eax,%eax <== NOT EXECUTED 116829: 74 74 je 11689f <_Watchdog_Adjust_to_chain+0x87> <== NOT EXECUTED return; } _ISR_Disable( level ); 11682b: 9c pushf <== NOT EXECUTED 11682c: fa cli <== NOT EXECUTED 11682d: 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 116830: 8d 7e 04 lea 0x4(%esi),%edi <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 116833: 39 3e cmp %edi,(%esi) <== NOT EXECUTED 116835: 74 64 je 11689b <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 116837: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11683a: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 11683d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 116840: 89 c3 mov %eax,%ebx <== NOT EXECUTED 116842: 8b 06 mov (%esi),%eax <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 116844: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED 116847: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 116849: 73 07 jae 116852 <_Watchdog_Adjust_to_chain+0x3a> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 11684b: 29 d9 sub %ebx,%ecx <== NOT EXECUTED 11684d: 89 48 10 mov %ecx,0x10(%eax) <== NOT EXECUTED 116850: eb 49 jmp 11689b <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 116852: 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( 116859: 8b 16 mov (%esi),%edx <== NOT EXECUTED 11685b: 39 fa cmp %edi,%edx <== NOT EXECUTED 11685d: 75 04 jne 116863 <_Watchdog_Adjust_to_chain+0x4b> <== NOT EXECUTED 11685f: 31 d2 xor %edx,%edx <== NOT EXECUTED 116861: eb 07 jmp 11686a <_Watchdog_Adjust_to_chain+0x52> <== NOT EXECUTED 116863: 8b 02 mov (%edx),%eax <== NOT EXECUTED 116865: 89 06 mov %eax,(%esi) <== NOT EXECUTED 116867: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED 11686a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11686d: 89 02 mov %eax,(%edx) <== NOT EXECUTED 11686f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116872: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 116875: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 116878: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11687b: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 11687e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116881: 89 10 mov %edx,(%eax) <== NOT EXECUTED 116883: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 116886: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 116889: 9d popf <== NOT EXECUTED 11688a: 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( 11688b: 8b 06 mov (%esi),%eax <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 11688d: 39 f8 cmp %edi,%eax <== NOT EXECUTED 11688f: 74 0a je 11689b <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 116891: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 116895: 74 c2 je 116859 <_Watchdog_Adjust_to_chain+0x41> <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 116897: 29 cb sub %ecx,%ebx <== NOT EXECUTED 116899: 75 a7 jne 116842 <_Watchdog_Adjust_to_chain+0x2a> <== NOT EXECUTED break; } } } _ISR_Enable( level ); 11689b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 11689e: 9d popf <== NOT EXECUTED } 11689f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1168a2: 5b pop %ebx <== NOT EXECUTED 1168a3: 5e pop %esi <== NOT EXECUTED 1168a4: 5f pop %edi <== NOT EXECUTED 1168a5: c9 leave <== NOT EXECUTED 1168a6: c3 ret <== NOT EXECUTED 0010bcb4 <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10bcb4: 55 push %ebp <== NOT EXECUTED 10bcb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10bcb7: c7 05 c4 d7 11 00 00 movl $0x0,0x11d7c4 <== NOT EXECUTED 10bcbe: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10bcc1: c7 05 34 d7 11 00 00 movl $0x0,0x11d734 <== NOT EXECUTED 10bcc8: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10bccb: c7 05 c8 d7 11 00 00 movl $0x0,0x11d7c8 <== NOT EXECUTED 10bcd2: 00 00 00 <== NOT EXECUTED 10bcd5: c7 05 58 d7 11 00 5c movl $0x11d75c,0x11d758 <== NOT EXECUTED 10bcdc: d7 11 00 <== NOT EXECUTED 10bcdf: c7 05 5c d7 11 00 00 movl $0x0,0x11d75c <== NOT EXECUTED 10bce6: 00 00 00 <== NOT EXECUTED 10bce9: c7 05 60 d7 11 00 58 movl $0x11d758,0x11d760 <== NOT EXECUTED 10bcf0: d7 11 00 <== NOT EXECUTED 10bcf3: c7 05 4c d7 11 00 50 movl $0x11d750,0x11d74c <== NOT EXECUTED 10bcfa: d7 11 00 <== NOT EXECUTED 10bcfd: c7 05 50 d7 11 00 00 movl $0x0,0x11d750 <== NOT EXECUTED 10bd04: 00 00 00 <== NOT EXECUTED 10bd07: c7 05 54 d7 11 00 4c movl $0x11d74c,0x11d754 <== NOT EXECUTED 10bd0e: d7 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10bd11: c9 leave <== NOT EXECUTED 10bd12: c3 ret <== NOT EXECUTED 0010bbfc <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10bbfc: 55 push %ebp <== NOT EXECUTED 10bbfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbff: 57 push %edi <== NOT EXECUTED 10bc00: 56 push %esi <== NOT EXECUTED 10bc01: 53 push %ebx <== NOT EXECUTED 10bc02: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bc05: 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; 10bc08: 8b 3d 14 d7 11 00 mov 0x11d714,%edi <== NOT EXECUTED _ISR_Disable( level ); 10bc0e: 9c pushf <== NOT EXECUTED 10bc0f: fa cli <== NOT EXECUTED 10bc10: 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 ) { 10bc13: 83 7e 08 00 cmpl $0x0,0x8(%esi) <== NOT EXECUTED 10bc17: 74 09 je 10bc22 <_Watchdog_Insert+0x26> <== NOT EXECUTED _ISR_Enable( level ); 10bc19: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bc1c: 9d popf <== NOT EXECUTED 10bc1d: e9 89 00 00 00 jmp 10bcab <_Watchdog_Insert+0xaf> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10bc22: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10bc29: a1 c4 d7 11 00 mov 0x11d7c4,%eax <== NOT EXECUTED 10bc2e: 40 inc %eax <== NOT EXECUTED 10bc2f: a3 c4 d7 11 00 mov %eax,0x11d7c4 <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10bc34: 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 ; 10bc37: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc3a: 8b 18 mov (%eax),%ebx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10bc3c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bc3e: 74 35 je 10bc75 <_Watchdog_Insert+0x79> <== NOT EXECUTED 10bc40: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10bc43: 74 30 je 10bc75 <_Watchdog_Insert+0x79> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10bc45: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 10bc48: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10bc4a: 73 07 jae 10bc53 <_Watchdog_Insert+0x57> <== NOT EXECUTED after->delta_interval -= delta_interval; 10bc4c: 29 ca sub %ecx,%edx <== NOT EXECUTED 10bc4e: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10bc51: eb 22 jmp 10bc75 <_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 ); 10bc53: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bc56: 9d popf <== NOT EXECUTED 10bc57: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10bc58: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10bc5c: 75 38 jne 10bc96 <_Watchdog_Insert+0x9a> <== NOT EXECUTED goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10bc5e: a1 34 d7 11 00 mov 0x11d734,%eax <== NOT EXECUTED 10bc63: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10bc65: 76 08 jbe 10bc6f <_Watchdog_Insert+0x73> <== NOT EXECUTED _Watchdog_Sync_level = insert_isr_nest_level; 10bc67: 89 3d 34 d7 11 00 mov %edi,0x11d734 <== NOT EXECUTED 10bc6d: eb c5 jmp 10bc34 <_Watchdog_Insert+0x38> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10bc6f: 29 d1 sub %edx,%ecx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bc71: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bc73: eb c7 jmp 10bc3c <_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( 10bc75: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10bc7c: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10bc7f: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc82: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10bc85: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc87: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10bc89: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10bc8b: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10bc8e: a1 c8 d7 11 00 mov 0x11d7c8,%eax <== NOT EXECUTED 10bc93: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10bc96: 89 3d 34 d7 11 00 mov %edi,0x11d734 <== NOT EXECUTED _Watchdog_Sync_count--; 10bc9c: a1 c4 d7 11 00 mov 0x11d7c4,%eax <== NOT EXECUTED 10bca1: 48 dec %eax <== NOT EXECUTED 10bca2: a3 c4 d7 11 00 mov %eax,0x11d7c4 <== NOT EXECUTED _ISR_Enable( level ); 10bca7: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bcaa: 9d popf <== NOT EXECUTED } 10bcab: 58 pop %eax <== NOT EXECUTED 10bcac: 5b pop %ebx <== NOT EXECUTED 10bcad: 5e pop %esi <== NOT EXECUTED 10bcae: 5f pop %edi <== NOT EXECUTED 10bcaf: c9 leave <== NOT EXECUTED 10bcb0: c3 ret <== NOT EXECUTED 0010bd14 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10bd14: 55 push %ebp <== NOT EXECUTED 10bd15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd17: 56 push %esi <== NOT EXECUTED 10bd18: 53 push %ebx <== NOT EXECUTED 10bd19: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10bd1c: 9c pushf <== NOT EXECUTED 10bd1d: fa cli <== NOT EXECUTED 10bd1e: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10bd1f: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10bd22: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10bd25: 74 09 je 10bd30 <_Watchdog_Remove+0x1c> <== NOT EXECUTED 10bd27: 72 41 jb 10bd6a <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bd29: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10bd2c: 77 3c ja 10bd6a <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bd2e: eb 09 jmp 10bd39 <_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; 10bd30: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10bd37: eb 31 jmp 10bd6a <_Watchdog_Remove+0x56> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10bd39: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bd40: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10bd42: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10bd45: 74 06 je 10bd4d <_Watchdog_Remove+0x39> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10bd47: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10bd4a: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10bd4d: a1 c4 d7 11 00 mov 0x11d7c4,%eax <== NOT EXECUTED 10bd52: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd54: 74 0a je 10bd60 <_Watchdog_Remove+0x4c> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10bd56: a1 14 d7 11 00 mov 0x11d714,%eax <== NOT EXECUTED 10bd5b: a3 34 d7 11 00 mov %eax,0x11d734 <== NOT EXECUTED 10bd60: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10bd62: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10bd65: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10bd68: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10bd6a: a1 c8 d7 11 00 mov 0x11d7c8,%eax <== NOT EXECUTED 10bd6f: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bd72: 56 push %esi <== NOT EXECUTED 10bd73: 9d popf <== NOT EXECUTED return( previous_state ); } 10bd74: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bd76: 5b pop %ebx <== NOT EXECUTED 10bd77: 5e pop %esi <== NOT EXECUTED 10bd78: c9 leave <== NOT EXECUTED 10bd79: c3 ret <== NOT EXECUTED 0010bd7c <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10bd7c: 55 push %ebp <== NOT EXECUTED 10bd7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd7f: 57 push %edi <== NOT EXECUTED 10bd80: 56 push %esi <== NOT EXECUTED 10bd81: 53 push %ebx <== NOT EXECUTED 10bd82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd85: 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 ); 10bd88: 9c pushf <== NOT EXECUTED 10bd89: fa cli <== NOT EXECUTED 10bd8a: 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( 10bd8b: 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 10bd8d: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10bd90: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10bd93: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bd95: 74 44 je 10bddb <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bd97: 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) { 10bd99: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bd9c: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd9e: 74 08 je 10bda8 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED the_watchdog->delta_interval--; 10bda0: 48 dec %eax <== NOT EXECUTED 10bda1: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10bda4: 85 c0 test %eax,%eax <== NOT EXECUTED 10bda6: 75 33 jne 10bddb <_Watchdog_Tickle+0x5f> <== NOT EXECUTED goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10bda8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdab: 53 push %ebx <== NOT EXECUTED 10bdac: e8 63 ff ff ff call 10bd14 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10bdb1: 56 push %esi <== NOT EXECUTED 10bdb2: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10bdb3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdb6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10bdb9: 75 0e jne 10bdc9 <_Watchdog_Tickle+0x4d> <== NOT EXECUTED case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10bdbb: 50 push %eax <== NOT EXECUTED 10bdbc: 50 push %eax <== NOT EXECUTED 10bdbd: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10bdc0: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10bdc3: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10bdc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10bdc9: 9c pushf <== NOT EXECUTED 10bdca: fa cli <== NOT EXECUTED 10bdcb: 5e pop %esi <== NOT EXECUTED 10bdcc: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10bdce: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 10bdd1: 74 08 je 10bddb <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bdd3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bdd5: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10bdd9: eb cb jmp 10bda6 <_Watchdog_Tickle+0x2a> <== NOT EXECUTED leave: _ISR_Enable(level); 10bddb: 56 push %esi <== NOT EXECUTED 10bddc: 9d popf <== NOT EXECUTED } 10bddd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bde0: 5b pop %ebx <== NOT EXECUTED 10bde1: 5e pop %esi <== NOT EXECUTED 10bde2: 5f pop %edi <== NOT EXECUTED 10bde3: c9 leave <== NOT EXECUTED 10bde4: c3 ret <== NOT EXECUTED 0010bdfd <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10bdfd: 55 push %ebp <== NOT EXECUTED 10bdfe: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be00: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10be03: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be06: 68 9c d6 11 00 push $0x11d69c <== NOT EXECUTED 10be0b: e8 10 21 00 00 call 10df20 <_Heap_Allocate> <== NOT EXECUTED } 10be10: c9 leave <== NOT EXECUTED 10be11: c3 ret <== NOT EXECUTED 0010be12 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10be12: 55 push %ebp <== NOT EXECUTED 10be13: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be15: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10be18: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be1b: 68 9c d6 11 00 push $0x11d69c <== NOT EXECUTED 10be20: e8 fb 20 00 00 call 10df20 <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10be25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be28: 85 c0 test %eax,%eax <== NOT EXECUTED 10be2a: 75 0c jne 10be38 <_Workspace_Allocate_or_fatal_error+0x26> <== NOT EXECUTED _Internal_error_Occurred( 10be2c: 50 push %eax <== NOT EXECUTED 10be2d: 6a 04 push $0x4 <== NOT EXECUTED 10be2f: 6a 01 push $0x1 <== NOT EXECUTED 10be31: 6a 00 push $0x0 <== NOT EXECUTED 10be33: e8 90 e3 ff ff call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10be38: c9 leave <== NOT EXECUTED 10be39: c3 ret <== NOT EXECUTED 0010bde8 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10bde8: 55 push %ebp <== NOT EXECUTED 10bde9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdeb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10bdee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bdf1: 68 9c d6 11 00 push $0x11d69c <== NOT EXECUTED 10bdf6: e8 91 21 00 00 call 10df8c <_Heap_Free> <== NOT EXECUTED } 10bdfb: c9 leave <== NOT EXECUTED 10bdfc: c3 ret <== NOT EXECUTED 0010be3a <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10be3a: 55 push %ebp <== NOT EXECUTED 10be3b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be3d: 57 push %edi <== NOT EXECUTED 10be3e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10be41: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10be44: 85 d2 test %edx,%edx <== NOT EXECUTED 10be46: 74 05 je 10be4d <_Workspace_Handler_initialization+0x13> <== NOT EXECUTED 10be48: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10be4b: 74 05 je 10be52 <_Workspace_Handler_initialization+0x18> <== NOT EXECUTED _Internal_error_Occurred( 10be4d: 51 push %ecx <== NOT EXECUTED 10be4e: 6a 02 push $0x2 <== NOT EXECUTED 10be50: eb 2e jmp 10be80 <_Workspace_Handler_initialization+0x46> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10be52: a1 10 d7 11 00 mov 0x11d710,%eax <== NOT EXECUTED 10be57: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10be5b: 74 09 je 10be66 <_Workspace_Handler_initialization+0x2c> <== NOT EXECUTED memset( starting_address, 0, size ); 10be5d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10be5f: 89 d7 mov %edx,%edi <== NOT EXECUTED 10be61: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10be64: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED memory_available = _Heap_Initialize( 10be66: 6a 04 push $0x4 <== NOT EXECUTED 10be68: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10be6b: 52 push %edx <== NOT EXECUTED 10be6c: 68 9c d6 11 00 push $0x11d69c <== NOT EXECUTED 10be71: e8 8a e1 ff ff call 10a000 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10be76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be79: 85 c0 test %eax,%eax <== NOT EXECUTED 10be7b: 75 0c jne 10be89 <_Workspace_Handler_initialization+0x4f> <== NOT EXECUTED _Internal_error_Occurred( 10be7d: 52 push %edx <== NOT EXECUTED 10be7e: 6a 03 push $0x3 <== NOT EXECUTED 10be80: 6a 01 push $0x1 <== NOT EXECUTED 10be82: 6a 00 push $0x0 <== NOT EXECUTED 10be84: e8 3f e3 ff ff call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10be89: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10be8c: c9 leave <== NOT EXECUTED 10be8d: 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 71 11 00 mov $0x117109,%edx <== NOT EXECUTED 106286: 85 c0 test %eax,%eax <== NOT EXECUTED 106288: 75 07 jne 106291 <__assert_func+0x19> <== NOT EXECUTED 10628a: ba a1 71 11 00 mov $0x1171a1,%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 71 11 00 push $0x117116 <== 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 b6 34 00 00 call 109768 <== NOT EXECUTED 0011cc08 <__env_lock>: 11cc08: 55 push %ebp <== NOT EXECUTED 11cc09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11cc0b: c9 leave <== NOT EXECUTED 11cc0c: c3 ret <== NOT EXECUTED 0011cc10 <__env_unlock>: 11cc10: 55 push %ebp <== NOT EXECUTED 11cc11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11cc13: c9 leave <== NOT EXECUTED 11cc14: c3 ret <== NOT EXECUTED 001154a0 <_calloc_r>: void *_calloc_r( struct _reent *ignored, size_t elements, size_t size ) { 1154a0: 55 push %ebp <== NOT EXECUTED 1154a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1154a3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return calloc( elements, size ); 1154a6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1154a9: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1154ac: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 1154af: c9 leave <== NOT EXECUTED struct _reent *ignored, size_t elements, size_t size ) { return calloc( elements, size ); 1154b0: e9 ab 77 ff ff jmp 10cc60 <== NOT EXECUTED 0010cd11 <_close_r>: int _close_r( struct _reent *ptr, int fd ) { 10cd11: 55 push %ebp <== NOT EXECUTED 10cd12: 89 e5 mov %esp,%ebp <== NOT EXECUTED return close( fd ); 10cd14: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cd17: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cd1a: c9 leave <== NOT EXECUTED int _close_r( struct _reent *ptr, int fd ) { return close( fd ); 10cd1b: e9 7c ff ff ff jmp 10cc9c <== NOT EXECUTED 001156ca <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 1156ca: 55 push %ebp <== NOT EXECUTED 1156cb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1156cd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1156d0: e8 28 07 00 00 call 115dfd <_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(); 1156d5: e8 8a ff ff ff call 115664 <== NOT EXECUTED rtems_shutdown_executive(status); 1156da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1156dd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1156e0: e8 d7 00 00 00 call 1157bc <== NOT EXECUTED 1156e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1156e8: eb fe jmp 1156e8 <_exit+0x1e> <== NOT EXECUTED 00129a92 <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) { 129a92: 55 push %ebp <== NOT EXECUTED 129a93: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129a95: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 129a98: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 129a9b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 129a9e: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 129aa1: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 129aa4: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 129aa7: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 129aa8: e9 9f fe ff ff jmp 12994c <== NOT EXECUTED 001154b8 <_free_r>: void _free_r( struct _reent *ignored, void *ptr ) { 1154b8: 55 push %ebp <== NOT EXECUTED 1154b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED free( ptr ); 1154bb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1154be: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1154c1: c9 leave <== NOT EXECUTED void _free_r( struct _reent *ignored, void *ptr ) { free( ptr ); 1154c2: e9 a1 0f ff ff jmp 106468 <== NOT EXECUTED 00115554 <_fstat_r>: int _fstat_r( struct _reent *ptr, int fd, struct stat *buf ) { 115554: 55 push %ebp <== NOT EXECUTED 115555: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115557: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return fstat( fd, buf ); 11555a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11555d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 115560: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 115563: c9 leave <== NOT EXECUTED struct _reent *ptr, int fd, struct stat *buf ) { return fstat( fd, buf ); 115564: e9 5f ff ff ff jmp 1154c8 <== NOT EXECUTED 0011ddfa <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 11ddfa: 55 push %ebp <== NOT EXECUTED 11ddfb: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 11ddfd: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11de02: c9 leave <== NOT EXECUTED 11de03: c3 ret <== NOT EXECUTED 0010ce34 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10ce34: 55 push %ebp <== NOT EXECUTED 10ce35: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10ce37: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10ce38: e9 a7 ff ff ff jmp 10cde4 <== NOT EXECUTED 0010ce3d <_gettimeofday_r>: int _gettimeofday_r( struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { 10ce3d: 55 push %ebp <== NOT EXECUTED 10ce3e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce40: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return gettimeofday( tp, tzp ); 10ce43: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ce46: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ce49: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10ce4c: c9 leave <== NOT EXECUTED struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10ce4d: e9 92 ff ff ff jmp 10cde4 <== NOT EXECUTED 0011dfcc <_kill_r>: int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 11dfcc: 55 push %ebp <== NOT EXECUTED 11dfcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11dfcf: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 11dfd2: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return killinfo( pid, sig, NULL ); 11dfd5: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 11dfdc: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11dfdf: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 11dfe2: c9 leave <== NOT EXECUTED struct _reent *ptr, pid_t pid, int sig ) { return killinfo( pid, sig, NULL ); 11dfe3: e9 84 00 00 00 jmp 11e06c <== NOT EXECUTED 0012004e <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) { 12004e: 55 push %ebp <== NOT EXECUTED 12004f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120051: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return link( existing, new ); 120054: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 120057: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 12005a: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 12005d: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 12005e: e9 3d fe ff ff jmp 11fea0 <== NOT EXECUTED 00115639 <_lseek_r>: struct _reent *ptr, int fd, off_t offset, int whence ) { 115639: 55 push %ebp <== NOT EXECUTED 11563a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11563c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11563f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return lseek( fd, offset, whence ); 115642: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 115645: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 115648: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11564b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 11564e: c9 leave <== NOT EXECUTED int fd, off_t offset, int whence ) { return lseek( fd, offset, whence ); 11564f: e9 4c ff ff ff jmp 1155a0 <== NOT EXECUTED 001201b7 <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 1201b7: 55 push %ebp <== NOT EXECUTED 1201b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1201ba: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 1201bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1201c0: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1201c3: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 1201c6: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 1201c7: e9 4c ff ff ff jmp 120118 <== NOT EXECUTED 00115654 <_malloc_r>: void *_malloc_r( struct _reent *ignored, size_t size ) { 115654: 55 push %ebp <== NOT EXECUTED 115655: 89 e5 mov %esp,%ebp <== NOT EXECUTED return malloc( size ); 115657: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11565a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11565d: c9 leave <== NOT EXECUTED void *_malloc_r( struct _reent *ignored, size_t size ) { return malloc( size ); 11565e: e9 01 10 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 0011576d <_read_r>: struct _reent *ptr, int fd, void *buf, size_t nbytes ) { 11576d: 55 push %ebp <== NOT EXECUTED 11576e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115770: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 115773: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return read( fd, buf, nbytes ); 115776: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 115779: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11577c: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11577f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 115782: c9 leave <== NOT EXECUTED int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes ); 115783: e9 64 ff ff ff jmp 1156ec <== NOT EXECUTED 00115788 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 115788: 55 push %ebp <== NOT EXECUTED 115789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11578b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 11578e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115791: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 115794: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 115797: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 115798: e9 4f 00 00 00 jmp 1157ec <== NOT EXECUTED 00139508 <_rename_r>: int _rename_r( struct _reent *ptr, const char *old, const char *new ) { 139508: 55 push %ebp <== NOT EXECUTED 139509: 89 e5 mov %esp,%ebp <== NOT EXECUTED 13950b: 53 push %ebx <== NOT EXECUTED 13950c: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 13950f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat sb; int s; s = stat( old, &sb); 139512: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 139515: 50 push %eax <== NOT EXECUTED 139516: 53 push %ebx <== NOT EXECUTED 139517: e8 70 1e fd ff call 10b38c <== NOT EXECUTED if ( s < 0 ) 13951c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 13951f: 85 c0 test %eax,%eax <== NOT EXECUTED 139521: 78 38 js 13955b <_rename_r+0x53> <== NOT EXECUTED return s; s = link( old, new ); 139523: 50 push %eax <== NOT EXECUTED 139524: 50 push %eax <== NOT EXECUTED 139525: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 139528: 53 push %ebx <== NOT EXECUTED 139529: e8 72 69 fe ff call 11fea0 <== NOT EXECUTED if ( s < 0 ) 13952e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 139531: 85 c0 test %eax,%eax <== NOT EXECUTED 139533: 78 26 js 13955b <_rename_r+0x53> <== NOT EXECUTED return s; return S_ISDIR(sb.st_mode) ? rmdir( old ) : unlink( old ); 139535: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 139538: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 13953d: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 139542: 75 0b jne 13954f <_rename_r+0x47> <== NOT EXECUTED 139544: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 139547: 53 push %ebx <== NOT EXECUTED 139548: e8 a7 71 fe ff call 1206f4 <== NOT EXECUTED 13954d: eb 09 jmp 139558 <_rename_r+0x50> <== NOT EXECUTED 13954f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 139552: 53 push %ebx <== NOT EXECUTED 139553: e8 f4 37 fd ff call 10cd4c <== NOT EXECUTED 139558: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 13955b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 13955e: c9 leave <== NOT EXECUTED 13955f: 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 001157a0 <_write_r>: struct _reent *ptr, int fd, const void *buf, size_t nbytes ) { 1157a0: 55 push %ebp <== NOT EXECUTED 1157a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1157a3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1157a6: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return write( fd, buf, nbytes ); 1157a9: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1157ac: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1157af: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1157b2: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1157b5: c9 leave <== NOT EXECUTED int fd, const void *buf, size_t nbytes ) { return write( fd, buf, nbytes ); 1157b6: e9 25 01 00 00 jmp 1158e0 <== NOT EXECUTED 0011e9c0 : int access( const char *path, int amode ) { 11e9c0: 55 push %ebp <== NOT EXECUTED 11e9c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e9c3: 53 push %ebx <== NOT EXECUTED 11e9c4: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 11e9c7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat statbuf; if ( stat(path, &statbuf) ) 11e9ca: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 11e9cd: 50 push %eax <== NOT EXECUTED 11e9ce: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11e9d1: e8 b6 c9 fe ff call 10b38c <== NOT EXECUTED 11e9d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e9d9: 85 c0 test %eax,%eax <== NOT EXECUTED 11e9db: 75 21 jne 11e9fe <== NOT EXECUTED return -1; if ( amode & R_OK ) { 11e9dd: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 11e9e0: 74 06 je 11e9e8 <== NOT EXECUTED if (!( statbuf.st_mode & S_IREAD )) 11e9e2: f6 45 bd 01 testb $0x1,-0x43(%ebp) <== NOT EXECUTED 11e9e6: 74 16 je 11e9fe <== NOT EXECUTED return -1; } if ( amode & W_OK ) { 11e9e8: f6 c3 02 test $0x2,%bl <== NOT EXECUTED 11e9eb: 74 06 je 11e9f3 <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) 11e9ed: 80 7d bc 00 cmpb $0x0,-0x44(%ebp) <== NOT EXECUTED 11e9f1: 79 0b jns 11e9fe <== NOT EXECUTED return -1; } if ( amode & X_OK ) { 11e9f3: 80 e3 01 and $0x1,%bl <== NOT EXECUTED 11e9f6: 74 0b je 11ea03 <== NOT EXECUTED if ( !( statbuf.st_mode & S_IEXEC ) ) 11e9f8: f6 45 bc 40 testb $0x40,-0x44(%ebp) <== NOT EXECUTED 11e9fc: 75 05 jne 11ea03 <== NOT EXECUTED 11e9fe: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11ea01: eb 02 jmp 11ea05 <== NOT EXECUTED 11ea03: 31 c0 xor %eax,%eax <== NOT EXECUTED return -1; } return 0; } 11ea05: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11ea08: c9 leave <== NOT EXECUTED 11ea09: c3 ret <== NOT EXECUTED 00108d98 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 108d98: 55 push %ebp <== NOT EXECUTED 108d99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108d9b: 57 push %edi <== NOT EXECUTED 108d9c: 56 push %esi <== NOT EXECUTED 108d9d: 53 push %ebx <== NOT EXECUTED 108d9e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108da1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108da4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED long adjustment; /* * Simple validations */ if ( !delta ) 108da7: 85 db test %ebx,%ebx <== NOT EXECUTED 108da9: 74 09 je 108db4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 108dab: 81 7b 04 3f 42 0f 00 cmpl $0xf423f,0x4(%ebx) <== NOT EXECUTED 108db2: 76 13 jbe 108dc7 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 108db4: e8 03 6a 00 00 call 10f7bc <__errno> <== NOT EXECUTED 108db9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 108dbf: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108dc2: e9 9e 00 00 00 jmp 108e65 <== NOT EXECUTED if ( olddelta ) { 108dc7: 85 f6 test %esi,%esi <== NOT EXECUTED 108dc9: 74 0d je 108dd8 <== NOT EXECUTED olddelta->tv_sec = 0; 108dcb: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED olddelta->tv_usec = 0; 108dd1: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 108dd8: 69 03 40 42 0f 00 imul $0xf4240,(%ebx),%eax <== NOT EXECUTED adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 108dde: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 108de1: 3b 05 f4 f5 11 00 cmp 0x11f5f4,%eax <== NOT EXECUTED 108de7: 72 7a jb 108e63 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108de9: a1 58 f4 11 00 mov 0x11f458,%eax <== NOT EXECUTED 108dee: 40 inc %eax <== NOT EXECUTED 108def: a3 58 f4 11 00 mov %eax,0x11f458 <== NOT EXECUTED * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 108df4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108df7: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 108dfa: 50 push %eax <== NOT EXECUTED 108dfb: e8 30 17 00 00 call 10a530 <_TOD_Get> <== NOT EXECUTED ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 108e00: 69 7b 04 e8 03 00 00 imul $0x3e8,0x4(%ebx),%edi <== NOT EXECUTED 108e07: 03 7d f0 add -0x10(%ebp),%edi <== NOT EXECUTED int adjtime( struct timeval *delta, struct timeval *olddelta ) { 108e0a: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 108e0f: 89 f8 mov %edi,%eax <== NOT EXECUTED 108e11: 31 d2 xor %edx,%edx <== NOT EXECUTED 108e13: f7 f1 div %ecx <== NOT EXECUTED 108e15: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 108e18: 89 c1 mov %eax,%ecx <== NOT EXECUTED 108e1a: 03 0b add (%ebx),%ecx <== NOT EXECUTED 108e1c: 03 4d ec add -0x14(%ebp),%ecx <== NOT EXECUTED 108e1f: 69 c0 00 36 65 c4 imul $0xc4653600,%eax,%eax <== NOT EXECUTED 108e25: 01 f8 add %edi,%eax <== NOT EXECUTED 108e27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e2a: eb 05 jmp 108e31 <== NOT EXECUTED 108e2c: 05 00 ca 9a 3b add $0x3b9aca00,%eax <== NOT EXECUTED 108e31: 89 ca mov %ecx,%edx <== NOT EXECUTED 108e33: 49 dec %ecx <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 108e34: 3d 00 36 65 c4 cmp $0xc4653600,%eax <== NOT EXECUTED 108e39: 76 f1 jbe 108e2c <== NOT EXECUTED 108e3b: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 108e3e: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 108e41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e44: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 108e47: 50 push %eax <== NOT EXECUTED 108e48: e8 73 17 00 00 call 10a5c0 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 108e4d: e8 8a 26 00 00 call 10b4dc <_Thread_Enable_dispatch> <== NOT EXECUTED /* set the user's output */ if ( olddelta ) 108e52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e55: 85 f6 test %esi,%esi <== NOT EXECUTED 108e57: 74 0a je 108e63 <== NOT EXECUTED *olddelta = *delta; 108e59: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 108e5b: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 108e5e: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 108e61: 89 16 mov %edx,(%esi) <== NOT EXECUTED 108e63: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 108e65: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108e68: 5b pop %ebx <== NOT EXECUTED 108e69: 5e pop %esi <== NOT EXECUTED 108e6a: 5f pop %edi <== NOT EXECUTED 108e6b: c9 leave <== NOT EXECUTED 108e6c: c3 ret <== NOT EXECUTED 00108f78 : int aio_cancel( int filedes, struct aiocb *aiocbp ) { 108f78: 55 push %ebp <== NOT EXECUTED 108f79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f7b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108f7e: e8 51 6e 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108f83: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 108f89: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108f8c: c9 leave <== NOT EXECUTED 108f8d: c3 ret <== NOT EXECUTED 00108f90 : #include int aio_error( const struct aiocb *aiocbp ) { 108f90: 55 push %ebp <== NOT EXECUTED 108f91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f93: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108f96: e8 39 6e 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108f9b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 108fa1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108fa4: c9 leave <== NOT EXECUTED 108fa5: c3 ret <== NOT EXECUTED 00108fa8 : int aio_fsync( int op, struct aiocb *aiocbp ) { 108fa8: 55 push %ebp <== NOT EXECUTED 108fa9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108fae: e8 21 6e 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108fb3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 108fb9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108fbc: c9 leave <== NOT EXECUTED 108fbd: c3 ret <== NOT EXECUTED 00108fc0 : #include int aio_read( struct aiocb *aiocbp ) { 108fc0: 55 push %ebp <== NOT EXECUTED 108fc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fc3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108fc6: e8 09 6e 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108fcb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 108fd1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108fd4: c9 leave <== NOT EXECUTED 108fd5: c3 ret <== NOT EXECUTED 00108fd8 : #include int aio_return( const struct aiocb *aiocbp ) { 108fd8: 55 push %ebp <== NOT EXECUTED 108fd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fdb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108fde: e8 f1 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108fe3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 108fe9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108fec: c9 leave <== NOT EXECUTED 108fed: c3 ret <== NOT EXECUTED 00108ff0 : int aio_suspend( const struct aiocb * const list[], int nent, const struct timespec *timeout ) { 108ff0: 55 push %ebp <== NOT EXECUTED 108ff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ff3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 108ff6: e8 d9 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 108ffb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109001: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109004: c9 leave <== NOT EXECUTED 109005: c3 ret <== NOT EXECUTED 00109008 : #include int aio_write( struct aiocb *aiocbp ) { 109008: 55 push %ebp <== NOT EXECUTED 109009: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10900b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10900e: e8 c1 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109013: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109019: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10901c: c9 leave <== NOT EXECUTED 10901d: c3 ret <== NOT EXECUTED 0010a6dc : } unsigned int alarm( unsigned int seconds ) { 10a6dc: 55 push %ebp <== NOT EXECUTED 10a6dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a6df: 53 push %ebx <== NOT EXECUTED 10a6e0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10a6e3: 83 3d e4 27 12 00 00 cmpl $0x0,0x1227e4 <== NOT EXECUTED 10a6ea: 75 2c jne 10a718 <== 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. * 10a6ec: c7 05 d0 27 12 00 00 movl $0x0,0x1227d0 <== NOT EXECUTED 10a6f3: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a6f6: c7 05 e4 27 12 00 7b movl $0x10a77b,0x1227e4 <== NOT EXECUTED 10a6fd: a7 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a700: c7 05 e8 27 12 00 00 movl $0x0,0x1227e8 <== NOT EXECUTED 10a707: 00 00 00 <== NOT EXECUTED * the heap 10a70a: c7 05 ec 27 12 00 00 movl $0x0,0x1227ec <== NOT EXECUTED 10a711: 00 00 00 <== NOT EXECUTED 10a714: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a716: eb 43 jmp 10a75b <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10a718: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a71b: 68 c8 27 12 00 push $0x1227c8 <== NOT EXECUTED 10a720: e8 e7 41 00 00 call 10e90c <_Watchdog_Remove> <== NOT EXECUTED 10a725: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a728: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 10a72b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a72d: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a730: 77 29 ja 10a75b <== NOT EXECUTED * The stop_time and start_time fields are snapshots of ticks since * boot. Since alarm() is dealing in seconds, we must account for * this. */ remaining = the_timer->initial - 10a732: 8b 0d e0 27 12 00 mov 0x1227e0,%ecx <== NOT EXECUTED 10a738: 2b 0d dc 27 12 00 sub 0x1227dc,%ecx <== NOT EXECUTED 10a73e: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 10a743: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a745: f7 35 44 2a 12 00 divl 0x122a44 <== NOT EXECUTED 10a74b: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a74d: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a74f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a751: f7 f3 div %ebx <== NOT EXECUTED 10a753: 8b 1d d4 27 12 00 mov 0x1227d4,%ebx <== NOT EXECUTED 10a759: 29 c3 sub %eax,%ebx <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10a75b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a75e: a3 d4 27 12 00 mov %eax,0x1227d4 <== NOT EXECUTED size_t size ); 10a763: 50 push %eax <== NOT EXECUTED 10a764: 50 push %eax <== NOT EXECUTED 10a765: 68 c8 27 12 00 push $0x1227c8 <== NOT EXECUTED 10a76a: 68 7c 29 12 00 push $0x12297c <== NOT EXECUTED 10a76f: e8 80 40 00 00 call 10e7f4 <_Watchdog_Insert> <== NOT EXECUTED } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 10a774: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a776: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a779: c9 leave <== NOT EXECUTED 10a77a: c3 ret <== NOT EXECUTED 00108df8 : */ int alphasort( const void *d1, const void *d2 ) { 108df8: 55 push %ebp <== NOT EXECUTED 108df9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return(strcmp((*(struct dirent **)d1)->d_name, 108dfb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108dfe: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108e00: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 108e03: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 108e06: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108e09: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108e0b: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 108e0e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED (*(struct dirent **)d2)->d_name)); } 108e11: c9 leave <== NOT EXECUTED int alphasort( const void *d1, const void *d2 ) { return(strcmp((*(struct dirent **)d1)->d_name, 108e12: e9 19 a8 00 00 jmp 113630 <== NOT EXECUTED 0010cc60 : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10cc60: 55 push %ebp <== NOT EXECUTED 10cc61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc63: 57 push %edi <== NOT EXECUTED 10cc64: 53 push %ebx <== NOT EXECUTED 10cc65: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cc68: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10cc6b: ff 05 9c d5 11 00 incl 0x11d59c <== NOT EXECUTED length = nelem * elsize; 10cc71: 0f af 5d 08 imul 0x8(%ebp),%ebx <== NOT EXECUTED cptr = malloc( length ); 10cc75: 53 push %ebx <== NOT EXECUTED 10cc76: e8 e9 99 ff ff call 106664 <== NOT EXECUTED 10cc7b: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( cptr ) 10cc7d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cc80: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc82: 74 08 je 10cc8c <== NOT EXECUTED memset( cptr, '\0', length ); 10cc84: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cc86: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cc88: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10cc8a: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10cc8c: ff 0d 8c d5 11 00 decl 0x11d58c <== NOT EXECUTED return cptr; } 10cc92: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc94: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cc97: 5b pop %ebx <== NOT EXECUTED 10cc98: 5f pop %edi <== NOT EXECUTED 10cc99: c9 leave <== NOT EXECUTED 10cc9a: c3 ret <== NOT EXECUTED 0011eb9c : #include int chdir( const char *pathname ) { 11eb9c: 55 push %ebp <== NOT EXECUTED 11eb9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11eb9f: 57 push %edi <== NOT EXECUTED 11eba0: 56 push %esi <== NOT EXECUTED 11eba1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 11eba4: 6a 01 push $0x1 <== NOT EXECUTED 11eba6: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 11eba9: 56 push %esi <== NOT EXECUTED 11ebaa: 6a 01 push $0x1 <== NOT EXECUTED 11ebac: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11ebaf: e8 46 b3 fe ff call 109efa <== NOT EXECUTED pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 11ebb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ebb7: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11ebba: 85 c0 test %eax,%eax <== NOT EXECUTED 11ebbc: 0f 85 8d 00 00 00 jne 11ec4f <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 11ebc2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11ebc5: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 11ebc8: 85 d2 test %edx,%edx <== NOT EXECUTED 11ebca: 75 1d jne 11ebe9 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ebcc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ebcf: 85 c0 test %eax,%eax <== NOT EXECUTED 11ebd1: 74 09 je 11ebdc <== NOT EXECUTED 11ebd3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ebd6: 56 push %esi <== NOT EXECUTED 11ebd7: ff d0 call *%eax <== NOT EXECUTED 11ebd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ebdc: e8 6b c8 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ebe1: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ebe7: eb 2e jmp 11ec17 <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 11ebe9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ebec: 56 push %esi <== NOT EXECUTED 11ebed: ff d2 call *%edx <== NOT EXECUTED 11ebef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ebf2: 48 dec %eax <== NOT EXECUTED 11ebf3: 74 27 je 11ec1c <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ebf5: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11ebf8: 85 c0 test %eax,%eax <== NOT EXECUTED 11ebfa: 74 10 je 11ec0c <== NOT EXECUTED 11ebfc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ebff: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec01: 74 09 je 11ec0c <== NOT EXECUTED 11ec03: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec06: 56 push %esi <== NOT EXECUTED 11ec07: ff d0 call *%eax <== NOT EXECUTED 11ec09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 11ec0c: e8 3b c8 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ec11: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 11ec17: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11ec1a: eb 33 jmp 11ec4f <== NOT EXECUTED } rtems_filesystem_freenode( &rtems_filesystem_current ); 11ec1c: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11ec21: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 11ec24: 85 d2 test %edx,%edx <== NOT EXECUTED 11ec26: 74 13 je 11ec3b <== NOT EXECUTED 11ec28: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 11ec2b: 85 d2 test %edx,%edx <== NOT EXECUTED 11ec2d: 74 0c je 11ec3b <== NOT EXECUTED 11ec2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec32: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 11ec35: 50 push %eax <== NOT EXECUTED 11ec36: ff d2 call *%edx <== NOT EXECUTED 11ec38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 11ec3b: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11ec40: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 11ec43: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 11ec46: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11ec4b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11ec4d: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 11ec4f: 89 d0 mov %edx,%eax <== NOT EXECUTED 11ec51: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11ec54: 5e pop %esi <== NOT EXECUTED 11ec55: 5f pop %edi <== NOT EXECUTED 11ec56: c9 leave <== NOT EXECUTED 11ec57: 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 af 16 02 00 call 12b44c <__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 84 16 02 00 call 12b44c <__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 0011ec58 : int chown( const char *path, uid_t owner, gid_t group ) { 11ec58: 55 push %ebp <== NOT EXECUTED 11ec59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ec5b: 57 push %edi <== NOT EXECUTED 11ec5c: 56 push %esi <== NOT EXECUTED 11ec5d: 53 push %ebx <== NOT EXECUTED 11ec5e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11ec61: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11ec64: 66 89 45 e2 mov %ax,-0x1e(%ebp) <== NOT EXECUTED 11ec68: 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 ) ) 11ec6b: 6a 01 push $0x1 <== NOT EXECUTED 11ec6d: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 11ec70: 56 push %esi <== NOT EXECUTED 11ec71: 6a 00 push $0x0 <== NOT EXECUTED 11ec73: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11ec76: e8 7f b2 fe ff call 109efa <== NOT EXECUTED 11ec7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ec7e: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11ec81: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec83: 75 53 jne 11ecd8 <== NOT EXECUTED return -1; if ( !loc.ops->chown_h ) { 11ec85: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11ec88: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 11ec8b: 85 d2 test %edx,%edx <== NOT EXECUTED 11ec8d: 75 20 jne 11ecaf <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ec8f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11ec92: 85 c0 test %eax,%eax <== NOT EXECUTED 11ec94: 74 09 je 11ec9f <== NOT EXECUTED 11ec96: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ec99: 56 push %esi <== NOT EXECUTED 11ec9a: ff d0 call *%eax <== NOT EXECUTED 11ec9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ec9f: e8 a8 c7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11eca4: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ecaa: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11ecad: eb 29 jmp 11ecd8 <== NOT EXECUTED } result = (*loc.ops->chown_h)( &loc, owner, group ); 11ecaf: 50 push %eax <== NOT EXECUTED 11ecb0: 0f b7 c7 movzwl %di,%eax <== NOT EXECUTED 11ecb3: 50 push %eax <== NOT EXECUTED 11ecb4: 0f b7 45 e2 movzwl -0x1e(%ebp),%eax <== NOT EXECUTED 11ecb8: 50 push %eax <== NOT EXECUTED 11ecb9: 56 push %esi <== NOT EXECUTED 11ecba: ff d2 call *%edx <== NOT EXECUTED 11ecbc: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 11ecbe: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11ecc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ecc4: 85 c0 test %eax,%eax <== NOT EXECUTED 11ecc6: 74 10 je 11ecd8 <== NOT EXECUTED 11ecc8: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11eccb: 85 c0 test %eax,%eax <== NOT EXECUTED 11eccd: 74 09 je 11ecd8 <== NOT EXECUTED 11eccf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ecd2: 56 push %esi <== NOT EXECUTED 11ecd3: ff d0 call *%eax <== NOT EXECUTED 11ecd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 11ecd8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11ecda: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11ecdd: 5b pop %ebx <== NOT EXECUTED 11ecde: 5e pop %esi <== NOT EXECUTED 11ecdf: 5f pop %edi <== NOT EXECUTED 11ece0: c9 leave <== NOT EXECUTED 11ece1: c3 ret <== NOT EXECUTED 0011ece4 : #include int chroot( const char *pathname ) { 11ece4: 55 push %ebp <== NOT EXECUTED 11ece5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ece7: 57 push %edi <== NOT EXECUTED 11ece8: 56 push %esi <== NOT EXECUTED 11ece9: 53 push %ebx <== NOT EXECUTED 11ecea: 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) { 11eced: 81 3d a4 4b 14 00 58 cmpl $0x15b358,0x144ba4 <== NOT EXECUTED 11ecf4: b3 15 00 <== NOT EXECUTED 11ecf7: 75 1e jne 11ed17 <== NOT EXECUTED rtems_libio_set_private_env(); /* try to set a new private env*/ 11ecf9: e8 b3 17 00 00 call 1204b1 <== NOT EXECUTED if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 11ecfe: 81 3d a4 4b 14 00 58 cmpl $0x15b358,0x144ba4 <== NOT EXECUTED 11ed05: b3 15 00 <== NOT EXECUTED 11ed08: 75 0d jne 11ed17 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ed0a: e8 3d c7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ed0f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ed15: eb 22 jmp 11ed39 <== NOT EXECUTED } result = chdir(pathname); 11ed17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ed1a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11ed1d: e8 7a fe ff ff call 11eb9c <== NOT EXECUTED if (result) { 11ed22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ed25: 85 c0 test %eax,%eax <== NOT EXECUTED 11ed27: 74 15 je 11ed3e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( errno ); 11ed29: e8 1e c7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ed2e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11ed30: e8 17 c7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ed35: 8b 00 mov (%eax),%eax <== NOT EXECUTED 11ed37: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11ed39: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11ed3c: eb 4c jmp 11ed8a <== NOT EXECUTED } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 11ed3e: 6a 00 push $0x0 <== NOT EXECUTED 11ed40: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 11ed43: 50 push %eax <== NOT EXECUTED 11ed44: 6a 00 push $0x0 <== NOT EXECUTED 11ed46: 68 43 bf 13 00 push $0x13bf43 <== NOT EXECUTED 11ed4b: e8 aa b1 fe ff call 109efa <== NOT EXECUTED 11ed50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ed53: 85 c0 test %eax,%eax <== NOT EXECUTED 11ed55: 75 d2 jne 11ed29 <== 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); 11ed57: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11ed5c: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ed5f: 85 d2 test %edx,%edx <== NOT EXECUTED 11ed61: 74 13 je 11ed76 <== NOT EXECUTED 11ed63: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 11ed66: 85 d2 test %edx,%edx <== NOT EXECUTED 11ed68: 74 0c je 11ed76 <== NOT EXECUTED 11ed6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ed6d: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11ed70: 50 push %eax <== NOT EXECUTED 11ed71: ff d2 call *%edx <== NOT EXECUTED 11ed73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_root = loc; 11ed76: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11ed7b: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 11ed7e: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 11ed81: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11ed86: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11ed88: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11ed8a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11ed8d: 5b pop %ebx <== NOT EXECUTED 11ed8e: 5e pop %esi <== NOT EXECUTED 11ed8f: 5f pop %edi <== NOT EXECUTED 11ed90: c9 leave <== NOT EXECUTED 11ed91: c3 ret <== NOT EXECUTED 00109020 : int clock_getcpuclockid( pid_t pid, clockid_t *clock_id ) { 109020: 55 push %ebp <== NOT EXECUTED 109021: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109023: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 109026: e8 a9 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 10902b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109031: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109034: c9 leave <== NOT EXECUTED 109035: c3 ret <== NOT EXECUTED 00109038 : int clock_getenable_attr( clockid_t clock_id, int *attr ) { 109038: 55 push %ebp <== NOT EXECUTED 109039: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10903b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10903e: e8 91 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109043: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109049: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10904c: c9 leave <== NOT EXECUTED 10904d: c3 ret <== NOT EXECUTED 001097e0 : int clock_getres( clockid_t clock_id, struct timespec *res ) { 1097e0: 55 push %ebp <== NOT EXECUTED 1097e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097e3: 56 push %esi <== NOT EXECUTED 1097e4: 53 push %ebx <== NOT EXECUTED 1097e5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1097e8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !res ) 1097eb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1097ed: 74 29 je 109818 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 1097ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1097f2: 48 dec %eax <== NOT EXECUTED 1097f3: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1097f6: 77 20 ja 109818 <== NOT EXECUTED case CLOCK_REALTIME: case CLOCK_PROCESS_CPUTIME: case CLOCK_THREAD_CPUTIME: if ( res ) { res->tv_sec = _TOD_Microseconds_per_tick / 1000000; 1097f8: 8b 1d 6c 11 12 00 mov 0x12116c,%ebx <== NOT EXECUTED 1097fe: be 40 42 0f 00 mov $0xf4240,%esi <== NOT EXECUTED 109803: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109805: 31 d2 xor %edx,%edx <== NOT EXECUTED 109807: f7 f6 div %esi <== NOT EXECUTED 109809: 89 01 mov %eax,(%ecx) <== NOT EXECUTED res->tv_nsec = _TOD_Microseconds_per_tick * 1000; 10980b: 69 c3 e8 03 00 00 imul $0x3e8,%ebx,%eax <== NOT EXECUTED 109811: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED 109814: 31 c0 xor %eax,%eax <== NOT EXECUTED 109816: eb 0e jmp 109826 <== NOT EXECUTED /* _TOD_From_ticks( _TOD_Microseconds_per_tick, res ); */ } break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 109818: e8 73 6f 00 00 call 110790 <__errno> <== NOT EXECUTED 10981d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109823: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } return 0; } 109826: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109829: 5b pop %ebx <== NOT EXECUTED 10982a: 5e pop %esi <== NOT EXECUTED 10982b: c9 leave <== NOT EXECUTED 10982c: c3 ret <== NOT EXECUTED 00109830 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109830: 55 push %ebp <== NOT EXECUTED 109831: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109833: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109836: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109839: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 10983c: 85 d2 test %edx,%edx <== NOT EXECUTED 10983e: 74 3c je 10987c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) 109840: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109843: 75 0b jne 109850 <== NOT EXECUTED _TOD_Get(tp); 109845: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109848: 52 push %edx <== NOT EXECUTED 109849: e8 06 20 00 00 call 10b854 <_TOD_Get> <== NOT EXECUTED 10984e: eb 13 jmp 109863 <== NOT EXECUTED #ifdef CLOCK_MONOTONIC else if ( clock_id == CLOCK_MONOTONIC ) 109850: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109853: 74 05 je 10985a <== NOT EXECUTED _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 109855: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109858: 75 10 jne 10986a <== NOT EXECUTED _TOD_Get_uptime(tp); 10985a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10985d: 52 push %edx <== NOT EXECUTED 10985e: e8 45 20 00 00 call 10b8a8 <_TOD_Get_uptime> <== NOT EXECUTED 109863: 31 c0 xor %eax,%eax <== NOT EXECUTED 109865: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109868: eb 20 jmp 10988a <== NOT EXECUTED #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10986a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10986d: 75 0d jne 10987c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10986f: e8 1c 6f 00 00 call 110790 <__errno> <== NOT EXECUTED 109874: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 10987a: eb 0b jmp 109887 <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10987c: e8 0f 6f 00 00 call 110790 <__errno> <== NOT EXECUTED 109881: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109887: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return 0; } 10988a: c9 leave <== NOT EXECUTED 10988b: c3 ret <== NOT EXECUTED 001090ac : int clock_setenable_attr( clockid_t clock_id, int attr ) { 1090ac: 55 push %ebp <== NOT EXECUTED 1090ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1090b2: e8 1d 6d 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1090b7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1090bd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1090c0: c9 leave <== NOT EXECUTED 1090c1: c3 ret <== NOT EXECUTED 00120c5c : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 120c5c: 55 push %ebp <== NOT EXECUTED 120c5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120c5f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 120c62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 120c65: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 120c68: 85 d2 test %edx,%edx <== NOT EXECUTED 120c6a: 74 44 je 120cb0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 120c6c: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 120c6f: 75 28 jne 120c99 <== NOT EXECUTED if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 120c71: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) <== NOT EXECUTED 120c77: 76 37 jbe 120cb0 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 120c79: a1 cc ac 15 00 mov 0x15accc,%eax <== NOT EXECUTED 120c7e: 40 inc %eax <== NOT EXECUTED 120c7f: a3 cc ac 15 00 mov %eax,0x15accc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 120c84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120c87: 52 push %edx <== NOT EXECUTED 120c88: e8 27 13 00 00 call 121fb4 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 120c8d: e8 4e ed fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 120c92: 31 c0 xor %eax,%eax <== NOT EXECUTED 120c94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120c97: eb 25 jmp 120cbe <== NOT EXECUTED } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 120c99: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 120c9c: 74 05 je 120ca3 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 120c9e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 120ca1: 75 0d jne 120cb0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 120ca3: e8 a4 a7 00 00 call 12b44c <__errno> <== NOT EXECUTED 120ca8: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 120cae: eb 0b jmp 120cbb <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 120cb0: e8 97 a7 00 00 call 12b44c <__errno> <== NOT EXECUTED 120cb5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 120cbb: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return 0; } 120cbe: c9 leave <== NOT EXECUTED 120cbf: c3 ret <== NOT EXECUTED 0010cc9c : #include int close( int fd ) { 10cc9c: 55 push %ebp <== NOT EXECUTED 10cc9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc9f: 56 push %esi <== NOT EXECUTED 10cca0: 53 push %ebx <== NOT EXECUTED 10cca1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10cca4: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 10ccaa: 73 0f jae 10ccbb <== NOT EXECUTED iop = rtems_libio_iop(fd); 10ccac: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 10ccaf: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10ccb5: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10ccb9: 75 10 jne 10cccb <== NOT EXECUTED 10ccbb: e8 f8 23 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10ccc0: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10ccc6: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10ccc9: eb 3f jmp 10cd0a <== NOT EXECUTED rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10cccb: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10ccce: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ccd1: 31 f6 xor %esi,%esi <== NOT EXECUTED 10ccd3: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccd5: 74 0b je 10cce2 <== NOT EXECUTED rc = (*iop->handlers->close_h)( iop ); 10ccd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccda: 53 push %ebx <== NOT EXECUTED 10ccdb: ff d0 call *%eax <== NOT EXECUTED 10ccdd: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ccdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &iop->pathinfo ); 10cce2: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10cce5: 85 c0 test %eax,%eax <== NOT EXECUTED 10cce7: 74 13 je 10ccfc <== NOT EXECUTED 10cce9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10ccec: 85 d2 test %edx,%edx <== NOT EXECUTED 10ccee: 74 0c je 10ccfc <== NOT EXECUTED 10ccf0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccf3: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10ccf6: 50 push %eax <== NOT EXECUTED 10ccf7: ff d2 call *%edx <== NOT EXECUTED 10ccf9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_libio_free( iop ); 10ccfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccff: 53 push %ebx <== NOT EXECUTED 10cd00: e8 47 02 00 00 call 10cf4c <== NOT EXECUTED return rc; 10cd05: 89 f0 mov %esi,%eax <== NOT EXECUTED 10cd07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cd0a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cd0d: 5b pop %ebx <== NOT EXECUTED 10cd0e: 5e pop %esi <== NOT EXECUTED 10cd0f: c9 leave <== NOT EXECUTED 10cd10: c3 ret <== NOT EXECUTED 001297f8 : * close a directory. */ int closedir( DIR *dirp ) { 1297f8: 55 push %ebp <== NOT EXECUTED 1297f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1297fb: 56 push %esi <== NOT EXECUTED 1297fc: 53 push %ebx <== NOT EXECUTED 1297fd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED int fd; if ( !dirp ) 129800: 85 f6 test %esi,%esi <== NOT EXECUTED 129802: 75 15 jne 129819 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 129804: e8 43 1c 00 00 call 12b44c <__errno> <== NOT EXECUTED 129809: 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)); } 12980f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129812: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129815: 5b pop %ebx <== NOT EXECUTED 129816: 5e pop %esi <== NOT EXECUTED 129817: c9 leave <== NOT EXECUTED 129818: c3 ret <== NOT EXECUTED int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 129819: 8b 1e mov (%esi),%ebx <== NOT EXECUTED dirp->dd_fd = -1; 12981b: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED dirp->dd_loc = 0; 129821: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED (void)free((void *)dirp->dd_buf); 129828: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12982b: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 12982e: e8 e9 07 fe ff call 10a01c <== NOT EXECUTED (void)free((void *)dirp); 129833: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 129836: e8 e1 07 fe ff call 10a01c <== NOT EXECUTED return(close(fd)); 12983b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12983e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 129841: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129844: 5b pop %ebx <== NOT EXECUTED 129845: 5e pop %esi <== NOT EXECUTED 129846: 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)); 129847: e9 b4 05 fe ff jmp 109e00 <== NOT EXECUTED 00109128 : int filedes, void *dev_data_ptr, size_t nbyte, int *dev_info_ptr ) { 109128: 55 push %ebp <== NOT EXECUTED 109129: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10912b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10912e: e8 a1 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109133: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109139: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10913c: c9 leave <== NOT EXECUTED 10913d: c3 ret <== NOT EXECUTED 0010e682 : */ int device_close( rtems_libio_t *iop ) { 10e682: 55 push %ebp <== NOT EXECUTED 10e683: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e685: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e688: 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; 10e68b: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10e68e: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = 0; 10e691: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) <== NOT EXECUTED args.mode = 0; 10e698: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_close( 10e69f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10e6a2: 50 push %eax <== NOT EXECUTED 10e6a3: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10e6a6: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10e6a9: e8 de 06 00 00 call 10ed8c <== NOT EXECUTED 10e6ae: 89 c2 mov %eax,%edx <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10e6b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e6b5: 85 d2 test %edx,%edx <== NOT EXECUTED 10e6b7: 74 07 je 10e6c0 <== NOT EXECUTED return rtems_deviceio_errno(status); 10e6b9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e6bb: e8 bb fe ff ff call 10e57b <== NOT EXECUTED } return 0; } 10e6c0: c9 leave <== NOT EXECUTED 10e6c1: c3 ret <== NOT EXECUTED 0010e574 : int device_ftruncate( rtems_libio_t *iop, off_t length ) { 10e574: 55 push %ebp <== NOT EXECUTED 10e575: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10e577: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e579: c9 leave <== NOT EXECUTED 10e57a: c3 ret <== NOT EXECUTED 0010e5a5 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10e5a5: 55 push %ebp <== NOT EXECUTED 10e5a6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5a8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e5ab: 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; 10e5ae: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 10e5b1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e5b4: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 10e5b7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e5ba: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 10e5bd: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 10e5c0: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e5c3: 50 push %eax <== NOT EXECUTED 10e5c4: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10e5c7: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10e5ca: e8 fd 07 00 00 call 10edcc <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e5cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e5d2: 85 c0 test %eax,%eax <== NOT EXECUTED 10e5d4: 74 07 je 10e5dd <== NOT EXECUTED return rtems_deviceio_errno(status); 10e5d6: e8 a0 ff ff ff call 10e57b <== NOT EXECUTED 10e5db: eb 03 jmp 10e5e0 <== NOT EXECUTED return args.ioctl_return; 10e5dd: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10e5e0: c9 leave <== NOT EXECUTED 10e5e1: c3 ret <== NOT EXECUTED 0010e56c : off_t device_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10e56c: 55 push %ebp <== NOT EXECUTED 10e56d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return offset; } 10e56f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e572: c9 leave <== NOT EXECUTED 10e573: c3 ret <== NOT EXECUTED 0010e6c2 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10e6c2: 55 push %ebp <== NOT EXECUTED 10e6c3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6c5: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e6c8: 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; 10e6cb: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10e6ce: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10e6d1: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10e6d4: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.mode = mode; 10e6d7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10e6da: 89 45 fc mov %eax,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_open( 10e6dd: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10e6e0: 50 push %eax <== NOT EXECUTED 10e6e1: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10e6e4: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10e6e7: e8 20 07 00 00 call 10ee0c <== NOT EXECUTED 10e6ec: 89 c2 mov %eax,%edx <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e6ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6f1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e6f3: 85 d2 test %edx,%edx <== NOT EXECUTED 10e6f5: 74 07 je 10e6fe <== NOT EXECUTED return rtems_deviceio_errno(status); 10e6f7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e6f9: e8 7d fe ff ff call 10e57b <== NOT EXECUTED return 0; } 10e6fe: c9 leave <== NOT EXECUTED 10e6ff: c3 ret <== NOT EXECUTED 0010e632 : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10e632: 55 push %ebp <== NOT EXECUTED 10e633: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e635: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e638: 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; 10e63b: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10e63e: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10e641: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10e644: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 10e647: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e64a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10e64d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e650: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10e653: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e656: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10e659: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 10e660: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10e663: 50 push %eax <== NOT EXECUTED 10e664: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10e667: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10e66a: e8 dd 07 00 00 call 10ee4c <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e66f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e672: 85 c0 test %eax,%eax <== NOT EXECUTED 10e674: 74 07 je 10e67d <== NOT EXECUTED return rtems_deviceio_errno(status); 10e676: e8 00 ff ff ff call 10e57b <== NOT EXECUTED 10e67b: eb 03 jmp 10e680 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10e67d: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10e680: c9 leave <== NOT EXECUTED 10e681: c3 ret <== NOT EXECUTED 0010e5e2 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10e5e2: 55 push %ebp <== NOT EXECUTED 10e5e3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5e5: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e5e8: 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; 10e5eb: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10e5ee: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10e5f1: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10e5f4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = (void *) buffer; 10e5f7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e5fa: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10e5fd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e600: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10e603: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e606: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10e609: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_write( 10e610: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10e613: 50 push %eax <== NOT EXECUTED 10e614: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10e617: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10e61a: e8 6d 08 00 00 call 10ee8c <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e61f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e622: 85 c0 test %eax,%eax <== NOT EXECUTED 10e624: 74 07 je 10e62d <== NOT EXECUTED return rtems_deviceio_errno(status); 10e626: e8 50 ff ff ff call 10e57b <== NOT EXECUTED 10e62b: eb 03 jmp 10e630 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10e62d: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10e630: c9 leave <== NOT EXECUTED 10e631: 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 cf 1a 00 00 call 109768 <== 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 00106ef4 : #include int dup( int fildes ) { 106ef4: 55 push %ebp <== NOT EXECUTED 106ef5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106ef7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return fcntl( fildes, F_DUPFD, 0 ); 106efa: 6a 00 push $0x0 <== NOT EXECUTED 106efc: 6a 00 push $0x0 <== NOT EXECUTED 106efe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106f01: e8 9a 01 00 00 call 1070a0 <== NOT EXECUTED } 106f06: c9 leave <== NOT EXECUTED 106f07: c3 ret <== NOT EXECUTED 00106eac : int dup2( int fildes, int fildes2 ) { 106eac: 55 push %ebp <== NOT EXECUTED 106ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106eaf: 57 push %edi <== NOT EXECUTED 106eb0: 56 push %esi <== NOT EXECUTED 106eb1: 53 push %ebx <== NOT EXECUTED 106eb2: 83 ec 64 sub $0x64,%esp <== NOT EXECUTED 106eb5: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106eb8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 106ebb: 8d 5d a8 lea -0x58(%ebp),%ebx <== NOT EXECUTED 106ebe: 53 push %ebx <== NOT EXECUTED 106ebf: 57 push %edi <== NOT EXECUTED 106ec0: e8 af 04 00 00 call 107374 <== NOT EXECUTED if ( status == -1 ) 106ec5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ec8: 40 inc %eax <== NOT EXECUTED 106ec9: 74 1e je 106ee9 <== NOT EXECUTED /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 106ecb: 52 push %edx <== NOT EXECUTED 106ecc: 52 push %edx <== NOT EXECUTED 106ecd: 53 push %ebx <== NOT EXECUTED 106ece: 56 push %esi <== NOT EXECUTED 106ecf: e8 a0 04 00 00 call 107374 <== NOT EXECUTED if ( status == -1 ) 106ed4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ed7: 40 inc %eax <== NOT EXECUTED 106ed8: 74 0f je 106ee9 <== NOT EXECUTED /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 106eda: 50 push %eax <== NOT EXECUTED 106edb: 56 push %esi <== NOT EXECUTED 106edc: 6a 00 push $0x0 <== NOT EXECUTED 106ede: 57 push %edi <== NOT EXECUTED 106edf: e8 bc 01 00 00 call 1070a0 <== NOT EXECUTED 106ee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ee7: eb 03 jmp 106eec <== NOT EXECUTED 106ee9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 106eec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106eef: 5b pop %ebx <== NOT EXECUTED 106ef0: 5e pop %esi <== NOT EXECUTED 106ef1: 5f pop %edi <== NOT EXECUTED 106ef2: c9 leave <== NOT EXECUTED 106ef3: 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 e0 b5 11 00 mov 0x11b5e0,%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 0011f630 : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 11f630: 55 push %ebp <== NOT EXECUTED 11f631: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f633: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 11f636: a1 ac a2 15 00 mov 0x15a2ac,%eax <== NOT EXECUTED 11f63b: 85 c0 test %eax,%eax <== NOT EXECUTED 11f63d: 74 0c je 11f64b <== NOT EXECUTED fclose(group_fp); 11f63f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f642: 50 push %eax <== NOT EXECUTED 11f643: e8 50 bf 00 00 call 12b598 <== NOT EXECUTED 11f648: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11f64b: c9 leave <== NOT EXECUTED 11f64c: c3 ret <== NOT EXECUTED 0011f64d : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 11f64d: 55 push %ebp <== NOT EXECUTED 11f64e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f650: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 11f653: a1 c4 a1 15 00 mov 0x15a1c4,%eax <== NOT EXECUTED 11f658: 85 c0 test %eax,%eax <== NOT EXECUTED 11f65a: 74 0c je 11f668 <== NOT EXECUTED fclose(passwd_fp); 11f65c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f65f: 50 push %eax <== NOT EXECUTED 11f660: e8 33 bf 00 00 call 12b598 <== NOT EXECUTED 11f665: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11f668: c9 leave <== NOT EXECUTED 11f669: 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 e0 b5 11 00 mov 0x11b5e0,%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 71 11 00 push $0x1171a0 <== 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 71 11 00 push $0x11719e <== 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 e0 b5 11 00 mov 0x11b5e0,%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 71 11 00 push $0x11719e <== 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 00109158 : const char *path, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 109158: 55 push %ebp <== NOT EXECUTED 109159: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10915b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10915e: e8 71 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109163: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109169: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10916c: c9 leave <== NOT EXECUTED 10916d: c3 ret <== NOT EXECUTED 00109140 : const char *path, char const *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 109140: 55 push %ebp <== NOT EXECUTED 109141: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109143: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109146: e8 89 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 10914b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109151: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109154: c9 leave <== NOT EXECUTED 109155: c3 ret <== NOT EXECUTED 00109170 : const char *file, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 109170: 55 push %ebp <== NOT EXECUTED 109171: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109173: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109176: e8 59 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 10917b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109181: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109184: c9 leave <== NOT EXECUTED 109185: c3 ret <== NOT EXECUTED 001091a0 : int execv( const char *file, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 1091a0: 55 push %ebp <== NOT EXECUTED 1091a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091a3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1091a6: e8 29 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1091ab: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1091b1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1091b4: c9 leave <== NOT EXECUTED 1091b5: c3 ret <== NOT EXECUTED 00109188 : const char *path, char *const argv[], char *const envp[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 109188: 55 push %ebp <== NOT EXECUTED 109189: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10918b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10918e: e8 41 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109193: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109199: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10919c: c9 leave <== NOT EXECUTED 10919d: c3 ret <== NOT EXECUTED 001091b8 : int execvp( const char *path, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 1091b8: 55 push %ebp <== NOT EXECUTED 1091b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1091be: e8 11 6c 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1091c3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1091c9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1091cc: c9 leave <== NOT EXECUTED 1091cd: c3 ret <== NOT EXECUTED 0012984c : #include int fchdir( int fd ) { 12984c: 55 push %ebp <== NOT EXECUTED 12984d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12984f: 57 push %edi <== NOT EXECUTED 129850: 56 push %esi <== NOT EXECUTED 129851: 53 push %ebx <== NOT EXECUTED 129852: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 129855: 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 ); 129858: 3b 05 18 22 14 00 cmp 0x142218,%eax <== NOT EXECUTED 12985e: 73 11 jae 129871 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 129860: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 129863: 03 05 60 ab 15 00 add 0x15ab60,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 129869: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 12986c: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12986f: 75 10 jne 129881 <== NOT EXECUTED 129871: e8 d6 1b 00 00 call 12b44c <__errno> <== NOT EXECUTED 129876: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12987c: e9 8f 00 00 00 jmp 129910 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 129881: 80 e2 02 and $0x2,%dl <== NOT EXECUTED 129884: 75 0d jne 129893 <== NOT EXECUTED 129886: e8 c1 1b 00 00 call 12b44c <__errno> <== NOT EXECUTED 12988b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129891: eb 7d jmp 129910 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 129893: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 129896: 85 d2 test %edx,%edx <== NOT EXECUTED 129898: 74 07 je 1298a1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 12989a: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 12989d: 85 d2 test %edx,%edx <== NOT EXECUTED 12989f: 75 0d jne 1298ae <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1298a1: e8 a6 1b 00 00 call 12b44c <__errno> <== NOT EXECUTED 1298a6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1298ac: eb 62 jmp 129910 <== NOT EXECUTED } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 1298ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1298b1: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 1298b4: 53 push %ebx <== NOT EXECUTED 1298b5: ff d2 call *%edx <== NOT EXECUTED 1298b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1298ba: 48 dec %eax <== NOT EXECUTED 1298bb: 74 0d je 1298ca <== NOT EXECUTED RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 1298bd: e8 8a 1b 00 00 call 12b44c <__errno> <== NOT EXECUTED 1298c2: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1298c8: eb 46 jmp 129910 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 1298ca: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 1298cf: 8d 7d d4 lea -0x2c(%ebp),%edi <== NOT EXECUTED 1298d2: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 1298d5: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1298da: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 1298dc: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 1298df: b1 04 mov $0x4,%cl <== NOT EXECUTED 1298e1: 89 de mov %ebx,%esi <== NOT EXECUTED 1298e3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 1298e5: 6a 00 push $0x0 <== NOT EXECUTED 1298e7: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1298ea: 50 push %eax <== NOT EXECUTED 1298eb: 6a 00 push $0x0 <== NOT EXECUTED 1298ed: 68 43 bf 13 00 push $0x13bf43 <== NOT EXECUTED 1298f2: e8 03 06 fe ff call 109efa <== NOT EXECUTED 1298f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1298fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1298fc: 74 17 je 129915 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 1298fe: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 129903: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 129906: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 129909: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12990e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 129910: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129913: eb 2e jmp 129943 <== NOT EXECUTED return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 129915: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 129918: 85 c0 test %eax,%eax <== NOT EXECUTED 12991a: 74 13 je 12992f <== NOT EXECUTED 12991c: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 12991f: 85 d2 test %edx,%edx <== NOT EXECUTED 129921: 74 0c je 12992f <== NOT EXECUTED 129923: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129926: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 129929: 50 push %eax <== NOT EXECUTED 12992a: ff d2 call *%edx <== NOT EXECUTED 12992c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 12992f: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 129934: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 129937: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 12993a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12993f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 129941: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 129943: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129946: 5b pop %ebx <== NOT EXECUTED 129947: 5e pop %esi <== NOT EXECUTED 129948: 5f pop %edi <== NOT EXECUTED 129949: c9 leave <== NOT EXECUTED 12994a: c3 ret <== NOT EXECUTED 0011ef40 : int fchmod( int fd, mode_t mode ) { 11ef40: 55 push %ebp <== NOT EXECUTED 11ef41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11ef43: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11ef46: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11ef49: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11ef4c: 3b 05 18 22 14 00 cmp 0x142218,%eax <== NOT EXECUTED 11ef52: 73 11 jae 11ef65 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11ef54: 6b d0 34 imul $0x34,%eax,%edx <== NOT EXECUTED 11ef57: 03 15 60 ab 15 00 add 0x15ab60,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 11ef5d: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11ef60: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 11ef63: 75 0d jne 11ef72 <== NOT EXECUTED 11ef65: e8 e2 c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ef6a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11ef70: eb 39 jmp 11efab <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11ef72: a8 04 test $0x4,%al <== NOT EXECUTED 11ef74: 75 0d jne 11ef83 <== NOT EXECUTED 11ef76: e8 d1 c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ef7b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11ef81: eb 28 jmp 11efab <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 11ef83: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 11ef86: 83 78 1c 00 cmpl $0x0,0x1c(%eax) <== NOT EXECUTED 11ef8a: 75 0d jne 11ef99 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11ef8c: e8 bb c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ef91: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11ef97: eb 12 jmp 11efab <== NOT EXECUTED return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 11ef99: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 11ef9c: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 11ef9f: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 11efa2: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 11efa5: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED } 11efa8: 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 ); 11efa9: ff e1 jmp *%ecx <== NOT EXECUTED } 11efab: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11efae: c9 leave <== NOT EXECUTED 11efaf: c3 ret <== NOT EXECUTED 0011efb0 : int fchown( int fd, uid_t owner, gid_t group ) { 11efb0: 55 push %ebp <== NOT EXECUTED 11efb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11efb3: 56 push %esi <== NOT EXECUTED 11efb4: 53 push %ebx <== NOT EXECUTED 11efb5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11efb8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11efbb: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11efbe: 3b 05 18 22 14 00 cmp 0x142218,%eax <== NOT EXECUTED 11efc4: 73 11 jae 11efd7 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11efc6: 6b d0 34 imul $0x34,%eax,%edx <== NOT EXECUTED 11efc9: 03 15 60 ab 15 00 add 0x15ab60,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 11efcf: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11efd2: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 11efd5: 75 0d jne 11efe4 <== NOT EXECUTED 11efd7: e8 70 c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11efdc: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11efe2: eb 3f jmp 11f023 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11efe4: a8 04 test $0x4,%al <== NOT EXECUTED 11efe6: 75 0d jne 11eff5 <== NOT EXECUTED 11efe8: e8 5f c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11efed: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11eff3: eb 2e jmp 11f023 <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 11eff5: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 11eff8: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED 11effb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11effd: 75 0d jne 11f00c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11efff: e8 48 c4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f004: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11f00a: eb 17 jmp 11f023 <== NOT EXECUTED return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 11f00c: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 11f00f: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11f012: 0f b7 c6 movzwl %si,%eax <== NOT EXECUTED 11f015: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11f018: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 11f01b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11f01e: 5b pop %ebx <== NOT EXECUTED 11f01f: 5e pop %esi <== NOT EXECUTED 11f020: 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 ); 11f021: ff e1 jmp *%ecx <== NOT EXECUTED } 11f023: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11f026: 5b pop %ebx <== NOT EXECUTED 11f027: 5e pop %esi <== NOT EXECUTED 11f028: c9 leave <== NOT EXECUTED 11f029: c3 ret <== NOT EXECUTED 0012994c : int fcntl( int fd, int cmd, ... ) { 12994c: 55 push %ebp <== NOT EXECUTED 12994d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12994f: 57 push %edi <== NOT EXECUTED 129950: 56 push %esi <== NOT EXECUTED 129951: 53 push %ebx <== NOT EXECUTED 129952: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129955: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129958: 8d 55 10 lea 0x10(%ebp),%edx <== NOT EXECUTED int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 12995b: 8b 0d 18 22 14 00 mov 0x142218,%ecx <== NOT EXECUTED 129961: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 129963: 73 14 jae 129979 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 129965: 8b 35 60 ab 15 00 mov 0x15ab60,%esi <== NOT EXECUTED 12996b: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 12996e: 8d 1c 06 lea (%esi,%eax,1),%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 129971: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 129974: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 129977: 75 10 jne 129989 <== NOT EXECUTED 129979: e8 ce 1a 00 00 call 12b44c <__errno> <== NOT EXECUTED 12997e: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 129984: e9 fc 00 00 00 jmp 129a85 <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 129989: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) <== NOT EXECUTED 12998d: 0f 87 bf 00 00 00 ja 129a52 <== NOT EXECUTED 129993: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 129996: ff 24 bd 18 f3 13 00 jmp *0x13f318(,%edi,4) <== NOT EXECUTED case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 12999d: 8b 02 mov (%edx),%eax <== NOT EXECUTED if ( fd2 ) 12999f: 85 c0 test %eax,%eax <== NOT EXECUTED 1299a1: 74 0e je 1299b1 <== NOT EXECUTED diop = rtems_libio_iop( fd2 ); 1299a3: 31 d2 xor %edx,%edx <== NOT EXECUTED 1299a5: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 1299a7: 73 1a jae 1299c3 <== NOT EXECUTED 1299a9: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 1299ac: 8d 14 06 lea (%esi,%eax,1),%edx <== NOT EXECUTED 1299af: eb 12 jmp 1299c3 <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 1299b1: e8 47 09 fe ff call 10a2fd <== NOT EXECUTED 1299b6: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( diop == 0 ) { 1299b8: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 1299bb: 85 c0 test %eax,%eax <== NOT EXECUTED 1299bd: 0f 84 c5 00 00 00 je 129a88 <== NOT EXECUTED ret = -1; break; } } diop->handlers = iop->handlers; 1299c3: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 1299c6: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED diop->file_info = iop->file_info; 1299c9: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 1299cc: 89 42 2c mov %eax,0x2c(%edx) <== NOT EXECUTED diop->flags = iop->flags; 1299cf: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1299d2: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED diop->pathinfo = iop->pathinfo; 1299d5: 8d 7a 10 lea 0x10(%edx),%edi <== NOT EXECUTED 1299d8: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 1299db: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1299e0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ret = (int) (diop - rtems_libio_iops); 1299e2: 2b 15 60 ab 15 00 sub 0x15ab60,%edx <== NOT EXECUTED 1299e8: c1 fa 02 sar $0x2,%edx <== NOT EXECUTED 1299eb: 69 f2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%esi <== NOT EXECUTED 1299f1: eb 6c jmp 129a5f <== NOT EXECUTED break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 1299f3: 89 c6 mov %eax,%esi <== NOT EXECUTED 1299f5: c1 ee 0b shr $0xb,%esi <== NOT EXECUTED 1299f8: 83 e6 01 and $0x1,%esi <== NOT EXECUTED 1299fb: eb 66 jmp 129a63 <== 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 ) ) 1299fd: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 129a00: 74 05 je 129a07 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 129a02: 80 cc 08 or $0x8,%ah <== NOT EXECUTED 129a05: eb 03 jmp 129a0a <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 129a07: 80 e4 f7 and $0xf7,%ah <== NOT EXECUTED 129a0a: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 129a0d: 31 f6 xor %esi,%esi <== NOT EXECUTED 129a0f: eb 52 jmp 129a63 <== NOT EXECUTED break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 129a11: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129a14: 50 push %eax <== NOT EXECUTED 129a15: e8 96 07 fe ff call 10a1b0 <== NOT EXECUTED 129a1a: 89 c6 mov %eax,%esi <== NOT EXECUTED 129a1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129a1f: eb 3e jmp 129a5f <== NOT EXECUTED break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 129a21: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129a24: ff 32 pushl (%edx) <== NOT EXECUTED 129a26: e8 64 09 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); 129a2b: 25 01 02 00 00 and $0x201,%eax <== NOT EXECUTED 129a30: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 129a33: 81 e2 fe fd ff ff and $0xfffffdfe,%edx <== NOT EXECUTED 129a39: 09 c2 or %eax,%edx <== NOT EXECUTED 129a3b: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 129a3e: 31 f6 xor %esi,%esi <== NOT EXECUTED 129a40: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129a43: eb 1e jmp 129a63 <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 129a45: e8 02 1a 00 00 call 12b44c <__errno> <== NOT EXECUTED 129a4a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 129a50: eb 33 jmp 129a85 <== NOT EXECUTED ret = -1; break; default: errno = EINVAL; 129a52: e8 f5 19 00 00 call 12b44c <__errno> <== NOT EXECUTED 129a57: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129a5d: eb 26 jmp 129a85 <== NOT EXECUTED /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 129a5f: 85 f6 test %esi,%esi <== NOT EXECUTED 129a61: 78 25 js 129a88 <== NOT EXECUTED if (iop->handlers->fcntl_h) { 129a63: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 129a66: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 129a69: 85 c0 test %eax,%eax <== NOT EXECUTED 129a6b: 74 1b je 129a88 <== NOT EXECUTED int err = (*iop->handlers->fcntl_h)( cmd, iop ); 129a6d: 52 push %edx <== NOT EXECUTED 129a6e: 52 push %edx <== NOT EXECUTED 129a6f: 53 push %ebx <== NOT EXECUTED 129a70: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129a73: ff d0 call *%eax <== NOT EXECUTED 129a75: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err) { 129a77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129a7a: 85 c0 test %eax,%eax <== NOT EXECUTED 129a7c: 74 0a je 129a88 <== NOT EXECUTED errno = err; 129a7e: e8 c9 19 00 00 call 12b44c <__errno> <== NOT EXECUTED 129a83: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 129a85: 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; } 129a88: 89 f0 mov %esi,%eax <== NOT EXECUTED 129a8a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129a8d: 5b pop %ebx <== NOT EXECUTED 129a8e: 5e pop %esi <== NOT EXECUTED 129a8f: 5f pop %edi <== NOT EXECUTED 129a90: c9 leave <== NOT EXECUTED 129a91: c3 ret <== NOT EXECUTED 00107204 : #include int fdatasync( int fd ) { 107204: 55 push %ebp <== NOT EXECUTED 107205: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107207: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10720a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 10720d: 3b 05 38 d0 11 00 cmp 0x11d038,%eax <== NOT EXECUTED 107213: 73 11 jae 107226 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 107215: 6b d0 34 imul $0x34,%eax,%edx <== NOT EXECUTED 107218: 03 15 68 13 12 00 add 0x121368,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10721e: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107221: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 107224: 75 0d jne 107233 <== NOT EXECUTED 107226: e8 7d 9d 00 00 call 110fa8 <__errno> <== NOT EXECUTED 10722b: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 107231: eb 2e jmp 107261 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 107233: a8 04 test $0x4,%al <== NOT EXECUTED 107235: 75 0d jne 107244 <== NOT EXECUTED 107237: e8 6c 9d 00 00 call 110fa8 <__errno> <== NOT EXECUTED 10723c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107242: eb 1d jmp 107261 <== NOT EXECUTED /* * Now process the fdatasync(). */ if ( !iop->handlers->fdatasync_h ) 107244: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 107247: 8b 48 2c mov 0x2c(%eax),%ecx <== NOT EXECUTED 10724a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10724c: 75 0d jne 10725b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10724e: e8 55 9d 00 00 call 110fa8 <__errno> <== NOT EXECUTED 107253: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 107259: eb 06 jmp 107261 <== NOT EXECUTED return (*iop->handlers->fdatasync_h)( iop ); 10725b: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10725e: c9 leave <== NOT EXECUTED */ if ( !iop->handlers->fdatasync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fdatasync_h)( iop ); 10725f: ff e1 jmp *%ecx <== NOT EXECUTED } 107261: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107264: c9 leave <== NOT EXECUTED 107265: c3 ret <== NOT EXECUTED 00120a5e : 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 ) { 120a5e: 55 push %ebp <== NOT EXECUTED 120a5f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120a61: 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; 120a64: 8b 15 fc ab 15 00 mov 0x15abfc,%edx <== NOT EXECUTED 120a6a: eb 0e jmp 120a7a <== 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 ) { 120a6c: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 120a6f: 3b 41 0c cmp 0xc(%ecx),%eax <== NOT EXECUTED 120a72: 75 04 jne 120a78 <== NOT EXECUTED 120a74: b0 01 mov $0x1,%al <== NOT EXECUTED 120a76: eb 0c jmp 120a84 <== 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 ) { 120a78: 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 ); 120a7a: 81 fa 00 ac 15 00 cmp $0x15ac00,%edx <== NOT EXECUTED 120a80: 75 ea jne 120a6c <== NOT EXECUTED 120a82: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 120a84: c9 leave <== NOT EXECUTED 120a85: c3 ret <== NOT EXECUTED 001091d0 : #include #include int fork( void ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 1091d0: 55 push %ebp <== NOT EXECUTED 1091d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091d3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1091d6: e8 f9 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1091db: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1091e1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1091e4: c9 leave <== NOT EXECUTED 1091e5: c3 ret <== NOT EXECUTED 00107268 : long fpathconf( int fd, int name ) { 107268: 55 push %ebp <== NOT EXECUTED 107269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10726b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10726e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107271: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 107274: 3b 05 38 d0 11 00 cmp 0x11d038,%eax <== NOT EXECUTED 10727a: 73 11 jae 10728d <== NOT EXECUTED iop = rtems_libio_iop(fd); 10727c: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 10727f: 03 05 68 13 12 00 add 0x121368,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 107285: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 107288: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 10728b: 75 0d jne 10729a <== NOT EXECUTED 10728d: e8 16 9d 00 00 call 110fa8 <__errno> <== NOT EXECUTED 107292: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 107298: eb 5b jmp 1072f5 <== NOT EXECUTED rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 10729a: 80 e2 02 and $0x2,%dl <== NOT EXECUTED 10729d: 74 4b je 1072ea <== NOT EXECUTED /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 10729f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED switch ( name ) { 1072a2: 83 f9 0b cmp $0xb,%ecx <== NOT EXECUTED 1072a5: 77 43 ja 1072ea <== NOT EXECUTED 1072a7: ff 24 8d 9c ac 11 00 jmp *0x11ac9c(,%ecx,4) <== NOT EXECUTED case _PC_LINK_MAX: return_value = the_limits->link_max; 1072ae: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 1072b1: eb 45 jmp 1072f8 <== NOT EXECUTED break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 1072b3: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1072b6: eb 40 jmp 1072f8 <== NOT EXECUTED break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 1072b8: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED 1072bb: eb 3b jmp 1072f8 <== NOT EXECUTED break; case _PC_NAME_MAX: return_value = the_limits->name_max; 1072bd: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED 1072c0: eb 36 jmp 1072f8 <== NOT EXECUTED break; case _PC_PATH_MAX: return_value = the_limits->path_max; 1072c2: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 1072c5: eb 31 jmp 1072f8 <== NOT EXECUTED break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 1072c7: 8b 40 44 mov 0x44(%eax),%eax <== NOT EXECUTED 1072ca: eb 2c jmp 1072f8 <== NOT EXECUTED break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 1072cc: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 1072cf: eb 27 jmp 1072f8 <== NOT EXECUTED break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 1072d1: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 1072d4: eb 22 jmp 1072f8 <== NOT EXECUTED break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 1072d6: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 1072d9: eb 1d jmp 1072f8 <== NOT EXECUTED break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 1072db: 8b 40 48 mov 0x48(%eax),%eax <== NOT EXECUTED 1072de: eb 18 jmp 1072f8 <== NOT EXECUTED break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 1072e0: 8b 40 54 mov 0x54(%eax),%eax <== NOT EXECUTED 1072e3: eb 13 jmp 1072f8 <== NOT EXECUTED break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 1072e5: 8b 40 58 mov 0x58(%eax),%eax <== NOT EXECUTED 1072e8: eb 0e jmp 1072f8 <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1072ea: e8 b9 9c 00 00 call 110fa8 <__errno> <== NOT EXECUTED 1072ef: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1072f5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED break; } return return_value; } 1072f8: c9 leave <== NOT EXECUTED 1072f9: 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 94 d5 11 00 incl 0x11d594 <== 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 18 d8 11 00 03 cmpl $0x3,0x11d818 <== 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 b4 ba 11 00 mov 0x11bab4,%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 30 d5 11 00 push $0x11d530 <== NOT EXECUTED 1064b5: e8 86 44 00 00 call 10a940 <_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 4c d5 11 00 pushl 0x11d54c <== NOT EXECUTED 1064c7: ff 35 48 d5 11 00 pushl 0x11d548 <== NOT EXECUTED 1064cd: 53 push %ebx <== NOT EXECUTED 1064ce: 68 48 71 11 00 push $0x117148 <== 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 001203bc : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 1203bc: 55 push %ebp <== NOT EXECUTED 1203bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1203bf: 53 push %ebx <== NOT EXECUTED 1203c0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1203c3: 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 1203c6: 81 fb 58 b3 15 00 cmp $0x15b358,%ebx <== NOT EXECUTED 1203cc: 74 40 je 12040e <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 1203ce: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1203d1: 85 c0 test %eax,%eax <== NOT EXECUTED 1203d3: 74 13 je 1203e8 <== NOT EXECUTED 1203d5: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1203d8: 85 d2 test %edx,%edx <== NOT EXECUTED 1203da: 74 0c je 1203e8 <== NOT EXECUTED 1203dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1203df: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 1203e2: 50 push %eax <== NOT EXECUTED 1203e3: ff d2 call *%edx <== NOT EXECUTED 1203e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 1203e8: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 1203eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1203ed: 74 13 je 120402 <== NOT EXECUTED 1203ef: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1203f2: 85 d2 test %edx,%edx <== NOT EXECUTED 1203f4: 74 0c je 120402 <== NOT EXECUTED 1203f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1203f9: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1203fc: 50 push %eax <== NOT EXECUTED 1203fd: ff d2 call *%edx <== NOT EXECUTED 1203ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 120402: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 120405: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120408: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 120409: e9 0e 9c fe ff jmp 10a01c <== NOT EXECUTED } } 12040e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120411: c9 leave <== NOT EXECUTED 120412: c3 ret <== NOT EXECUTED 001154c8 : int fstat( int fd, struct stat *sbuf ) { 1154c8: 55 push %ebp <== NOT EXECUTED 1154c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1154cb: 57 push %edi <== NOT EXECUTED 1154cc: 56 push %esi <== NOT EXECUTED 1154cd: 53 push %ebx <== NOT EXECUTED 1154ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1154d1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1154d4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 1154d7: 85 f6 test %esi,%esi <== NOT EXECUTED 1154d9: 75 0d jne 1154e8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 1154db: e8 d8 9b ff ff call 10f0b8 <__errno> <== NOT EXECUTED 1154e0: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 1154e6: eb 54 jmp 11553c <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 1154e8: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 1154ee: 73 57 jae 115547 <== NOT EXECUTED 1154f0: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 1154f3: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 1154f9: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 1154fd: 74 48 je 115547 <== NOT EXECUTED if ( !iop->handlers ) 1154ff: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 115502: 85 c0 test %eax,%eax <== NOT EXECUTED 115504: 74 41 je 115547 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 115506: 83 78 18 00 cmpl $0x0,0x18(%eax) <== NOT EXECUTED 11550a: 75 0d jne 115519 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11550c: e8 a7 9b ff ff call 10f0b8 <__errno> <== NOT EXECUTED 115511: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 115517: eb 23 jmp 11553c <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 115519: b9 13 00 00 00 mov $0x13,%ecx <== NOT EXECUTED 11551e: 31 c0 xor %eax,%eax <== NOT EXECUTED 115520: 89 f7 mov %esi,%edi <== NOT EXECUTED 115522: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 115524: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 115527: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 11552a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 11552d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 115530: 8b 4a 18 mov 0x18(%edx),%ecx <== NOT EXECUTED } 115533: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115536: 5b pop %ebx <== NOT EXECUTED 115537: 5e pop %esi <== NOT EXECUTED 115538: 5f pop %edi <== NOT EXECUTED 115539: 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 ); 11553a: ff e1 jmp *%ecx <== NOT EXECUTED } 11553c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11553f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115542: 5b pop %ebx <== NOT EXECUTED 115543: 5e pop %esi <== NOT EXECUTED 115544: 5f pop %edi <== NOT EXECUTED 115545: c9 leave <== NOT EXECUTED 115546: c3 ret <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); 115547: e8 6c 9b ff ff call 10f0b8 <__errno> <== NOT EXECUTED 11554c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 115552: eb e8 jmp 11553c <== NOT EXECUTED 0011f0d0 : #include int fsync( int fd ) { 11f0d0: 55 push %ebp <== NOT EXECUTED 11f0d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f0d3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11f0d6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11f0d9: 3b 05 18 22 14 00 cmp 0x142218,%eax <== NOT EXECUTED 11f0df: 73 2a jae 11f10b <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11f0e1: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 11f0e4: 03 05 60 ab 15 00 add 0x15ab60,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 11f0ea: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 11f0ed: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 11f0f0: 74 19 je 11f10b <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11f0f2: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 11f0f5: 75 0d jne 11f104 <== NOT EXECUTED 11f0f7: e8 50 c3 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f0fc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f102: eb 2e jmp 11f132 <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) 11f104: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 11f107: 85 d2 test %edx,%edx <== NOT EXECUTED 11f109: 75 0d jne 11f118 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 11f10b: e8 3c c3 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f110: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11f116: eb 1a jmp 11f132 <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 11f118: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 11f11b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11f11d: 75 0d jne 11f12c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11f11f: e8 28 c3 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f124: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11f12a: eb 06 jmp 11f132 <== NOT EXECUTED return (*iop->handlers->fsync_h)( iop ); 11f12c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11f12f: 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 ); 11f130: ff e1 jmp *%ecx <== NOT EXECUTED } 11f132: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11f135: c9 leave <== NOT EXECUTED 11f136: c3 ret <== NOT EXECUTED 0010cd20 : int ftruncate( int fd, off_t length ) { 10cd20: 55 push %ebp <== NOT EXECUTED 10cd21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd23: 57 push %edi <== NOT EXECUTED 10cd24: 56 push %esi <== NOT EXECUTED 10cd25: 53 push %ebx <== NOT EXECUTED 10cd26: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cd29: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10cd2c: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 10cd32: 73 0f jae 10cd43 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 10cd34: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 10cd37: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10cd3d: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10cd41: 75 0d jne 10cd50 <== NOT EXECUTED 10cd43: e8 70 23 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cd48: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10cd4e: eb 5b jmp 10cdab <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10cd50: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10cd53: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10cd56: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cd5b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 10cd5d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10cd60: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 10cd63: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd65: 74 39 je 10cda0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10cd67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd6a: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10cd6d: 50 push %eax <== NOT EXECUTED 10cd6e: ff d2 call *%edx <== NOT EXECUTED 10cd70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd73: 48 dec %eax <== NOT EXECUTED 10cd74: 75 0d jne 10cd83 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 10cd76: e8 3d 23 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cd7b: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10cd81: eb 28 jmp 10cdab <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10cd83: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED 10cd87: 75 0d jne 10cd96 <== NOT EXECUTED 10cd89: e8 2a 23 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cd8e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10cd94: eb 15 jmp 10cdab <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10cd96: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10cd99: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10cd9c: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd9e: 75 10 jne 10cdb0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10cda0: e8 13 23 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cda5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cdab: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cdae: eb 0b jmp 10cdbb <== NOT EXECUTED return (*iop->handlers->ftruncate_h)( iop, length ); 10cdb0: 52 push %edx <== NOT EXECUTED 10cdb1: 52 push %edx <== NOT EXECUTED 10cdb2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cdb5: 53 push %ebx <== NOT EXECUTED 10cdb6: ff d0 call *%eax <== NOT EXECUTED 10cdb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cdbb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cdbe: 5b pop %ebx <== NOT EXECUTED 10cdbf: 5e pop %esi <== NOT EXECUTED 10cdc0: 5f pop %edi <== NOT EXECUTED 10cdc1: c9 leave <== NOT EXECUTED 10cdc2: c3 ret <== NOT EXECUTED 0011f1dc : char * getcwd ( char *pt, size_t size) { 11f1dc: 55 push %ebp <== NOT EXECUTED 11f1dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f1df: 57 push %edi <== NOT EXECUTED 11f1e0: 56 push %esi <== NOT EXECUTED 11f1e1: 53 push %ebx <== NOT EXECUTED 11f1e2: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 11f1e8: 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) 11f1eb: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11f1ef: 74 2a je 11f21b <== NOT EXECUTED { ptsize = 0; if (!size) 11f1f1: 85 c0 test %eax,%eax <== NOT EXECUTED 11f1f3: 75 17 jne 11f20c <== NOT EXECUTED { errno = EINVAL; 11f1f5: e8 52 c2 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f1fa: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f200: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 11f207: e9 c0 03 00 00 jmp 11f5cc <== NOT EXECUTED return (char *) NULL; } ept = pt + size; 11f20c: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 11f20f: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 11f212: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f219: eb 2a jmp 11f245 <== NOT EXECUTED } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 11f21b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f21e: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 11f223: e8 b4 b2 fe ff call 10a4dc <== NOT EXECUTED 11f228: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 11f22b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f22e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f230: 0f 84 96 03 00 00 je 11f5cc <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 11f236: 05 fc 03 00 00 add $0x3fc,%eax <== NOT EXECUTED 11f23b: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 11f23e: c7 45 8c fc 03 00 00 movl $0x3fc,-0x74(%ebp) <== NOT EXECUTED } bpt = ept - 1; 11f245: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 11f248: 48 dec %eax <== NOT EXECUTED 11f249: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED *bpt = '\0'; 11f24c: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 11f24f: 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))) 11f253: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f256: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 11f25b: e8 7c b2 fe ff call 10a4dc <== NOT EXECUTED 11f260: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f262: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f265: 85 c0 test %eax,%eax <== NOT EXECUTED 11f267: 0f 84 38 03 00 00 je 11f5a5 <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 11f26d: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED up[1] = '\0'; 11f270: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED /* Save root values, so know when to stop. */ if (stat ("/", &s)) 11f274: 50 push %eax <== NOT EXECUTED 11f275: 50 push %eax <== NOT EXECUTED 11f276: 8d 5d a8 lea -0x58(%ebp),%ebx <== NOT EXECUTED 11f279: 53 push %ebx <== NOT EXECUTED 11f27a: 68 e7 dd 13 00 push $0x13dde7 <== NOT EXECUTED 11f27f: e8 08 c1 fe ff call 10b38c <== NOT EXECUTED 11f284: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f287: 85 c0 test %eax,%eax <== NOT EXECUTED 11f289: 0f 85 16 03 00 00 jne 11f5a5 <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 11f28f: 8d be 00 04 00 00 lea 0x400(%esi),%edi <== NOT EXECUTED 11f295: 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; 11f298: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 11f29b: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 11f2a1: 8b 55 ac mov -0x54(%ebp),%edx <== NOT EXECUTED 11f2a4: 89 95 60 ff ff ff mov %edx,-0xa0(%ebp) <== NOT EXECUTED root_ino = s.st_ino; 11f2aa: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED 11f2ad: 89 7d 88 mov %edi,-0x78(%ebp) <== NOT EXECUTED errno = 0; /* XXX readdir has no error return. */ 11f2b0: e8 97 c1 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f2b5: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11f2bb: 89 75 84 mov %esi,-0x7c(%ebp) <== NOT EXECUTED 11f2be: c7 85 7c ff ff ff 01 movl $0x1,-0x84(%ebp) <== NOT EXECUTED 11f2c5: 00 00 00 <== NOT EXECUTED 11f2c8: 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)) 11f2cf: 57 push %edi <== NOT EXECUTED 11f2d0: 57 push %edi <== NOT EXECUTED 11f2d1: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 11f2d4: 50 push %eax <== NOT EXECUTED 11f2d5: 56 push %esi <== NOT EXECUTED 11f2d6: e8 b1 c0 fe ff call 10b38c <== NOT EXECUTED 11f2db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f2de: 85 c0 test %eax,%eax <== NOT EXECUTED 11f2e0: 0f 85 bf 02 00 00 jne 11f5a5 <== NOT EXECUTED goto err; /* Save current node values. */ ino = s.st_ino; 11f2e6: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED 11f2e9: 89 95 78 ff ff ff mov %edx,-0x88(%ebp) <== NOT EXECUTED dev = s.st_dev; 11f2ef: 8b 7d a8 mov -0x58(%ebp),%edi <== NOT EXECUTED 11f2f2: 89 bd 5c ff ff ff mov %edi,-0xa4(%ebp) <== NOT EXECUTED 11f2f8: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED 11f2fb: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) <== NOT EXECUTED /* Check for reaching root. */ if (root_dev == dev && root_ino == ino) 11f301: 39 85 60 ff ff ff cmp %eax,-0xa0(%ebp) <== NOT EXECUTED 11f307: 75 35 jne 11f33e <== NOT EXECUTED 11f309: 39 bd 64 ff ff ff cmp %edi,-0x9c(%ebp) <== NOT EXECUTED 11f30f: 75 2d jne 11f33e <== NOT EXECUTED 11f311: 39 55 88 cmp %edx,-0x78(%ebp) <== NOT EXECUTED 11f314: 75 28 jne 11f33e <== NOT EXECUTED { *--bpt = '/'; 11f316: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 11f319: 48 dec %eax <== NOT EXECUTED 11f31a: 8b 55 80 mov -0x80(%ebp),%edx <== NOT EXECUTED 11f31d: 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); 11f321: 53 push %ebx <== NOT EXECUTED 11f322: 29 45 98 sub %eax,-0x68(%ebp) <== NOT EXECUTED 11f325: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 11f328: 50 push %eax <== NOT EXECUTED 11f329: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f32c: e8 0f e3 00 00 call 12d640 <== NOT EXECUTED free (up); 11f331: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11f334: e8 e3 ac fe ff call 10a01c <== NOT EXECUTED 11f339: e9 8b 02 00 00 jmp 11f5c9 <== 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) 11f33e: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f341: 05 04 04 00 00 add $0x404,%eax <== NOT EXECUTED 11f346: 39 45 9c cmp %eax,-0x64(%ebp) <== NOT EXECUTED 11f349: 77 26 ja 11f371 <== NOT EXECUTED { if (!(up = (char *) realloc (up, upsize *= 2))) 11f34b: d1 65 90 shll -0x70(%ebp) <== NOT EXECUTED 11f34e: 51 push %ecx <== NOT EXECUTED 11f34f: 51 push %ecx <== NOT EXECUTED 11f350: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 11f353: 56 push %esi <== NOT EXECUTED 11f354: e8 3f bf fe ff call 10b298 <== NOT EXECUTED 11f359: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f35b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f35e: 85 c0 test %eax,%eax <== NOT EXECUTED 11f360: 0f 84 3f 02 00 00 je 11f5a5 <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 11f366: 8b 7d 90 mov -0x70(%ebp),%edi <== NOT EXECUTED 11f369: 01 c7 add %eax,%edi <== NOT EXECUTED 11f36b: 89 7d 9c mov %edi,-0x64(%ebp) <== NOT EXECUTED 11f36e: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED } *bup++ = '.'; 11f371: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f374: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED *bup++ = '.'; 11f377: c6 40 01 2e movb $0x2e,0x1(%eax) <== NOT EXECUTED 11f37b: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f37d: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED *bup = '\0'; 11f380: c6 40 02 00 movb $0x0,0x2(%eax) <== NOT EXECUTED /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 11f384: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f387: 56 push %esi <== NOT EXECUTED 11f388: e8 a7 0f 00 00 call 120334 <== NOT EXECUTED 11f38d: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp) <== NOT EXECUTED 11f393: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f396: 85 c0 test %eax,%eax <== NOT EXECUTED 11f398: 0f 84 07 02 00 00 je 11f5a5 <== NOT EXECUTED 11f39e: 52 push %edx <== NOT EXECUTED 11f39f: 52 push %edx <== NOT EXECUTED 11f3a0: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 11f3a3: 52 push %edx <== NOT EXECUTED 11f3a4: ff 30 pushl (%eax) <== NOT EXECUTED 11f3a6: e8 81 fc ff ff call 11f02c <== NOT EXECUTED 11f3ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f3ae: 85 c0 test %eax,%eax <== NOT EXECUTED 11f3b0: 0f 85 21 02 00 00 jne 11f5d7 <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 11f3b6: c6 03 2f movb $0x2f,(%ebx) <== NOT EXECUTED 11f3b9: 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) 11f3bd: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 11f3c3: 39 7d ac cmp %edi,-0x54(%ebp) <== NOT EXECUTED 11f3c6: 75 0b jne 11f3d3 <== NOT EXECUTED 11f3c8: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax <== NOT EXECUTED 11f3ce: 39 45 a8 cmp %eax,-0x58(%ebp) <== NOT EXECUTED 11f3d1: 74 09 je 11f3dc <== NOT EXECUTED 11f3d3: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f3da: eb 2a jmp 11f406 <== NOT EXECUTED { for (;;) { if (!(dp = _readdir (dir))) 11f3dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f3df: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f3e5: e8 ca 11 00 00 call 1205b4 <== NOT EXECUTED 11f3ea: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f3ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f3ef: 85 c0 test %eax,%eax <== NOT EXECUTED 11f3f1: 0f 84 84 01 00 00 je 11f57b <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 11f3f7: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx <== NOT EXECUTED 11f3fd: 39 10 cmp %edx,(%eax) <== NOT EXECUTED 11f3ff: 75 db jne 11f3dc <== NOT EXECUTED 11f401: e9 a8 00 00 00 jmp 11f4ae <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 11f406: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f409: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f40f: e8 a0 11 00 00 call 1205b4 <== NOT EXECUTED 11f414: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f416: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f419: 85 c0 test %eax,%eax <== NOT EXECUTED 11f41b: 0f 84 61 01 00 00 je 11f582 <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 11f421: 80 78 0c 2e cmpb $0x2e,0xc(%eax) <== NOT EXECUTED 11f425: 75 11 jne 11f438 <== NOT EXECUTED 11f427: 8a 40 0d mov 0xd(%eax),%al <== NOT EXECUTED 11f42a: 84 c0 test %al,%al <== NOT EXECUTED 11f42c: 74 d8 je 11f406 <== NOT EXECUTED 11f42e: 3c 2e cmp $0x2e,%al <== NOT EXECUTED 11f430: 75 06 jne 11f438 <== NOT EXECUTED 11f432: 80 7b 0e 00 cmpb $0x0,0xe(%ebx) <== NOT EXECUTED 11f436: 74 ce je 11f406 <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 11f438: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED 11f43b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f43d: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f440: 89 d7 mov %edx,%edi <== NOT EXECUTED 11f442: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f444: f7 d1 not %ecx <== NOT EXECUTED 11f446: 57 push %edi <== NOT EXECUTED 11f447: 51 push %ecx <== NOT EXECUTED 11f448: 52 push %edx <== NOT EXECUTED 11f449: ff 75 84 pushl -0x7c(%ebp) <== NOT EXECUTED 11f44c: e8 ef e1 00 00 call 12d640 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 11f451: 58 pop %eax <== NOT EXECUTED 11f452: 5a pop %edx <== NOT EXECUTED 11f453: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 11f456: 50 push %eax <== NOT EXECUTED 11f457: 56 push %esi <== NOT EXECUTED 11f458: e8 2f bf fe ff call 10b38c <== NOT EXECUTED 11f45d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f460: 85 c0 test %eax,%eax <== NOT EXECUTED 11f462: 74 1d je 11f481 <== NOT EXECUTED { if (!save_errno) 11f464: 83 7d 94 00 cmpl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f468: 75 0a jne 11f474 <== NOT EXECUTED save_errno = errno; 11f46a: e8 dd bf 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f46f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 11f471: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED errno = 0; 11f474: e8 d3 bf 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f479: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11f47f: eb 85 jmp 11f406 <== NOT EXECUTED continue; } if (s.st_dev == dev && s.st_ino == ino) 11f481: 8b 95 58 ff ff ff mov -0xa8(%ebp),%edx <== NOT EXECUTED 11f487: 39 55 ac cmp %edx,-0x54(%ebp) <== NOT EXECUTED 11f48a: 0f 85 76 ff ff ff jne 11f406 <== NOT EXECUTED 11f490: 8b bd 5c ff ff ff mov -0xa4(%ebp),%edi <== NOT EXECUTED 11f496: 39 7d a8 cmp %edi,-0x58(%ebp) <== NOT EXECUTED 11f499: 0f 85 67 ff ff ff jne 11f406 <== NOT EXECUTED 11f49f: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED 11f4a5: 39 45 b0 cmp %eax,-0x50(%ebp) <== NOT EXECUTED 11f4a8: 0f 85 58 ff ff ff jne 11f406 <== NOT EXECUTED /* * Check for length of the current name, preceding slash, * leading slash. */ if (bpt - pt <= strlen (dp->d_name) + (first ? 1 : 2)) 11f4ae: 8b 55 80 mov -0x80(%ebp),%edx <== NOT EXECUTED 11f4b1: 2b 55 08 sub 0x8(%ebp),%edx <== NOT EXECUTED 11f4b4: 89 55 a0 mov %edx,-0x60(%ebp) <== NOT EXECUTED 11f4b7: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 11f4ba: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f4bc: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f4bf: 89 df mov %ebx,%edi <== NOT EXECUTED 11f4c1: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f4c3: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 11f4c9: f7 d8 neg %eax <== NOT EXECUTED 11f4cb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 11f4cd: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11f4cf: 77 5a ja 11f52b <== NOT EXECUTED { size_t len, off; if (!ptsize) 11f4d1: 83 7d 8c 00 cmpl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f4d5: 75 10 jne 11f4e7 <== NOT EXECUTED { errno = ERANGE; 11f4d7: e8 70 bf 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f4dc: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED 11f4e2: e9 f0 00 00 00 jmp 11f5d7 <== NOT EXECUTED goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 11f4e7: d1 65 8c shll -0x74(%ebp) <== NOT EXECUTED 11f4ea: 57 push %edi <== NOT EXECUTED 11f4eb: 57 push %edi <== NOT EXECUTED 11f4ec: ff 75 8c pushl -0x74(%ebp) <== NOT EXECUTED 11f4ef: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f4f2: e8 a1 bd fe ff call 10b298 <== NOT EXECUTED 11f4f7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 11f4fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f4fd: 85 c0 test %eax,%eax <== NOT EXECUTED 11f4ff: 0f 84 d2 00 00 00 je 11f5d7 <== NOT EXECUTED { errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; 11f505: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 11f508: 2b 45 80 sub -0x80(%ebp),%eax <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 11f50b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11f50e: 03 55 8c add -0x74(%ebp),%edx <== NOT EXECUTED 11f511: 89 55 98 mov %edx,-0x68(%ebp) <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 11f514: 29 c2 sub %eax,%edx <== NOT EXECUTED 11f516: 89 55 80 mov %edx,-0x80(%ebp) <== NOT EXECUTED 11f519: 51 push %ecx <== NOT EXECUTED 11f51a: 50 push %eax <== NOT EXECUTED 11f51b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f51e: 03 45 a0 add -0x60(%ebp),%eax <== NOT EXECUTED 11f521: 50 push %eax <== NOT EXECUTED 11f522: 52 push %edx <== NOT EXECUTED 11f523: e8 18 e1 00 00 call 12d640 <== NOT EXECUTED 11f528: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bpt = ept - len; } if (!first) 11f52b: 83 bd 7c ff ff ff 00 cmpl $0x0,-0x84(%ebp) <== NOT EXECUTED 11f532: 75 09 jne 11f53d <== NOT EXECUTED *--bpt = '/'; 11f534: ff 4d 80 decl -0x80(%ebp) <== NOT EXECUTED 11f537: 8b 7d 80 mov -0x80(%ebp),%edi <== NOT EXECUTED 11f53a: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED bpt -= strlen (dp->d_name); 11f53d: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f53f: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 11f542: 89 df mov %ebx,%edi <== NOT EXECUTED 11f544: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 11f546: f7 d1 not %ecx <== NOT EXECUTED 11f548: 49 dec %ecx <== NOT EXECUTED 11f549: 29 4d 80 sub %ecx,-0x80(%ebp) <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 11f54c: 52 push %edx <== NOT EXECUTED 11f54d: 51 push %ecx <== NOT EXECUTED 11f54e: 53 push %ebx <== NOT EXECUTED 11f54f: ff 75 80 pushl -0x80(%ebp) <== NOT EXECUTED 11f552: e8 e9 e0 00 00 call 12d640 <== NOT EXECUTED (void) _closedir (dir); 11f557: 58 pop %eax <== NOT EXECUTED 11f558: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f55e: e8 95 a2 00 00 call 1297f8 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 11f563: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 11f566: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 11f569: c7 85 7c ff ff ff 00 movl $0x0,-0x84(%ebp) <== NOT EXECUTED 11f570: 00 00 00 <== NOT EXECUTED 11f573: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f576: e9 54 fd ff ff jmp 11f2cf <== NOT EXECUTED } 11f57b: 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) 11f582: e8 c5 be 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f587: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 11f58a: 75 4b jne 11f5d7 <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; 11f58c: e8 bb be 00 00 call 12b44c <__errno> <== NOT EXECUTED 11f591: 83 7d 94 00 cmpl $0x0,-0x6c(%ebp) <== NOT EXECUTED 11f595: 75 07 jne 11f59e <== NOT EXECUTED 11f597: c7 45 94 02 00 00 00 movl $0x2,-0x6c(%ebp) <== NOT EXECUTED 11f59e: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 11f5a1: 89 10 mov %edx,(%eax) <== NOT EXECUTED 11f5a3: eb 32 jmp 11f5d7 <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 11f5a5: 83 7d 8c 00 cmpl $0x0,-0x74(%ebp) <== NOT EXECUTED 11f5a9: 74 0e je 11f5b9 <== NOT EXECUTED free (pt); 11f5ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f5ae: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11f5b1: e8 66 aa fe ff call 10a01c <== NOT EXECUTED 11f5b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free (up); 11f5b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f5bc: 56 push %esi <== NOT EXECUTED 11f5bd: e8 5a aa fe ff call 10a01c <== NOT EXECUTED 11f5c2: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 11f5c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return (char *) NULL; } 11f5cc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f5cf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f5d2: 5b pop %ebx <== NOT EXECUTED 11f5d3: 5e pop %esi <== NOT EXECUTED 11f5d4: 5f pop %edi <== NOT EXECUTED 11f5d5: c9 leave <== NOT EXECUTED 11f5d6: c3 ret <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 11f5d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f5da: ff b5 74 ff ff ff pushl -0x8c(%ebp) <== NOT EXECUTED 11f5e0: e8 13 a2 00 00 call 1297f8 <== NOT EXECUTED 11f5e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f5e8: eb bb jmp 11f5a5 <== NOT EXECUTED 00129ab0 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 129ab0: 55 push %ebp <== NOT EXECUTED 129ab1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129ab3: 57 push %edi <== NOT EXECUTED 129ab4: 56 push %esi <== NOT EXECUTED 129ab5: 53 push %ebx <== NOT EXECUTED 129ab6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 129ab9: 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 ); 129abc: 31 db xor %ebx,%ebx <== NOT EXECUTED 129abe: 3b 05 18 22 14 00 cmp 0x142218,%eax <== NOT EXECUTED 129ac4: 73 09 jae 129acf <== NOT EXECUTED 129ac6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 129ac9: 03 1d 60 ab 15 00 add 0x15ab60,%ebx <== NOT EXECUTED /* * Make sure we are working on a directory */ loc = iop->pathinfo; 129acf: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 129ad2: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 129ad5: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 129ada: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 129adc: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 129adf: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 129ae2: 85 d2 test %edx,%edx <== NOT EXECUTED 129ae4: 74 29 je 129b0f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 129ae6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129ae9: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 129aec: 50 push %eax <== NOT EXECUTED 129aed: ff d2 call *%edx <== NOT EXECUTED 129aef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129af2: 48 dec %eax <== NOT EXECUTED 129af3: 74 10 je 129b05 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 129af5: e8 52 19 00 00 call 12b44c <__errno> <== NOT EXECUTED 129afa: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 129b00: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 129b03: eb 24 jmp 129b29 <== NOT EXECUTED /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 129b05: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 129b08: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 129b0b: 85 c0 test %eax,%eax <== NOT EXECUTED 129b0d: 75 0d jne 129b1c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 129b0f: e8 38 19 00 00 call 12b44c <__errno> <== NOT EXECUTED 129b14: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 129b1a: eb e4 jmp 129b00 <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 129b1c: 52 push %edx <== NOT EXECUTED 129b1d: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 129b20: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129b23: 53 push %ebx <== NOT EXECUTED 129b24: ff d0 call *%eax <== NOT EXECUTED 129b26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 129b29: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129b2c: 5b pop %ebx <== NOT EXECUTED 129b2d: 5e pop %esi <== NOT EXECUTED 129b2e: 5f pop %edi <== NOT EXECUTED 129b2f: c9 leave <== NOT EXECUTED 129b30: c3 ret <== NOT EXECUTED 0010cdc4 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getegid( void ) { 10cdc4: 55 push %ebp <== NOT EXECUTED 10cdc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdc7: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cdcc: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED return _POSIX_types_Egid; } 10cdcf: c9 leave <== NOT EXECUTED 10cdd0: c3 ret <== NOT EXECUTED 0010cdd4 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t geteuid( void ) { 10cdd4: 55 push %ebp <== NOT EXECUTED 10cdd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdd7: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cddc: 66 8b 40 2e mov 0x2e(%eax),%ax <== NOT EXECUTED return _POSIX_types_Euid; } 10cde0: c9 leave <== NOT EXECUTED 10cde1: c3 ret <== NOT EXECUTED 0011f60c : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 11f60c: 55 push %ebp <== NOT EXECUTED 11f60d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f60f: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11f614: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 11f617: c9 leave <== NOT EXECUTED 11f618: c3 ret <== NOT EXECUTED 0011fb0f : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fb0f: 55 push %ebp <== NOT EXECUTED 11fb10: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fb12: 57 push %edi <== NOT EXECUTED 11fb13: 56 push %esi <== NOT EXECUTED 11fb14: 53 push %ebx <== NOT EXECUTED 11fb15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fb18: 89 c7 mov %eax,%edi <== NOT EXECUTED 11fb1a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 11fb1d: 89 ce mov %ecx,%esi <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 11fb1f: e8 df fe ff ff call 11fa03 <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 11fb24: 50 push %eax <== NOT EXECUTED 11fb25: 50 push %eax <== NOT EXECUTED 11fb26: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fb2b: 68 08 dd 13 00 push $0x13dd08 <== NOT EXECUTED 11fb30: e8 cf c1 00 00 call 12bd04 <== NOT EXECUTED 11fb35: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fb37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fb3a: 85 c0 test %eax,%eax <== NOT EXECUTED 11fb3c: 75 10 jne 11fb4e <== NOT EXECUTED errno = EINVAL; 11fb3e: e8 09 b9 00 00 call 12b44c <__errno> <== NOT EXECUTED 11fb43: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11fb49: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fb4c: eb 6b jmp 11fbb9 <== NOT EXECUTED return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 11fb4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fb51: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11fb54: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11fb57: 89 f2 mov %esi,%edx <== NOT EXECUTED 11fb59: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11fb5b: e8 42 fc ff ff call 11f7a2 <== NOT EXECUTED 11fb60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fb63: 85 c0 test %eax,%eax <== NOT EXECUTED 11fb65: 75 19 jne 11fb80 <== NOT EXECUTED errno = EINVAL; 11fb67: e8 e0 b8 00 00 call 12b44c <__errno> <== NOT EXECUTED 11fb6c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 11fb72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fb75: 53 push %ebx <== NOT EXECUTED 11fb76: e8 1d ba 00 00 call 12b598 <== NOT EXECUTED 11fb7b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fb7e: eb 36 jmp 11fbb6 <== NOT EXECUTED return -1; } if (name) { 11fb80: 85 ff test %edi,%edi <== NOT EXECUTED 11fb82: 74 11 je 11fb95 <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); 11fb84: 50 push %eax <== NOT EXECUTED 11fb85: 50 push %eax <== NOT EXECUTED 11fb86: 57 push %edi <== NOT EXECUTED 11fb87: ff 36 pushl (%esi) <== NOT EXECUTED 11fb89: e8 02 fd 00 00 call 12f890 <== NOT EXECUTED 11fb8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fb91: 85 c0 test %eax,%eax <== NOT EXECUTED 11fb93: eb 07 jmp 11fb9c <== NOT EXECUTED } else { match = (grp->gr_gid == gid); 11fb95: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 11fb99: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 11fb9c: 0f 94 c0 sete %al <== NOT EXECUTED 11fb9f: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 11fba2: 85 c0 test %eax,%eax <== NOT EXECUTED 11fba4: 74 a8 je 11fb4e <== NOT EXECUTED fclose(fp); 11fba6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fba9: 53 push %ebx <== NOT EXECUTED 11fbaa: e8 e9 b9 00 00 call 12b598 <== NOT EXECUTED *result = grp; 11fbaf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11fbb2: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11fbb4: 31 c0 xor %eax,%eax <== NOT EXECUTED 11fbb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 11fbb9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11fbbc: 5b pop %ebx <== NOT EXECUTED 11fbbd: 5e pop %esi <== NOT EXECUTED 11fbbe: 5f pop %edi <== NOT EXECUTED 11fbbf: c9 leave <== NOT EXECUTED 11fbc0: c3 ret <== NOT EXECUTED 0011f898 : return NULL; return p; } struct group *getgrent() { 11f898: 55 push %ebp <== NOT EXECUTED 11f899: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f89b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 11f89e: a1 ac a2 15 00 mov 0x15a2ac,%eax <== NOT EXECUTED 11f8a3: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8a5: 74 23 je 11f8ca <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 11f8a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f8aa: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11f8af: b9 b0 a2 15 00 mov $0x15a2b0,%ecx <== NOT EXECUTED 11f8b4: ba 78 a3 15 00 mov $0x15a378,%edx <== NOT EXECUTED 11f8b9: e8 e4 fe ff ff call 11f7a2 <== NOT EXECUTED 11f8be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f8c1: ba 78 a3 15 00 mov $0x15a378,%edx <== NOT EXECUTED 11f8c6: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8c8: 75 02 jne 11f8cc <== NOT EXECUTED 11f8ca: 31 d2 xor %edx,%edx <== NOT EXECUTED return NULL; return &grent; } 11f8cc: 89 d0 mov %edx,%eax <== NOT EXECUTED 11f8ce: c9 leave <== NOT EXECUTED 11f8cf: c3 ret <== NOT EXECUTED 0011fbe7 : } struct group *getgrgid( gid_t gid ) { 11fbe7: 55 push %ebp <== NOT EXECUTED 11fbe8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fbea: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 11fbed: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fbf0: 50 push %eax <== NOT EXECUTED 11fbf1: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fbf6: 68 b0 a2 15 00 push $0x15a2b0 <== NOT EXECUTED 11fbfb: 68 78 a3 15 00 push $0x15a378 <== NOT EXECUTED 11fc00: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 11fc04: 50 push %eax <== NOT EXECUTED 11fc05: e8 b7 ff ff ff call 11fbc1 <== NOT EXECUTED 11fc0a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fc0d: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fc0f: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc11: 75 03 jne 11fc16 <== NOT EXECUTED return NULL; return p; 11fc13: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fc16: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fc18: c9 leave <== NOT EXECUTED 11fc19: c3 ret <== NOT EXECUTED 0011fbc1 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fbc1: 55 push %ebp <== NOT EXECUTED 11fbc2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fbc4: 53 push %ebx <== NOT EXECUTED 11fbc5: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fbc8: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 11fbcb: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 11fbcf: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11fbd2: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11fbd5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11fbd8: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11fbdb: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fbde: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11fbe0: 5b pop %ebx <== NOT EXECUTED 11fbe1: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 11fbe2: e9 28 ff ff ff jmp 11fb0f <== NOT EXECUTED 0011fc3f : } struct group *getgrnam( const char *name ) { 11fc3f: 55 push %ebp <== NOT EXECUTED 11fc40: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc42: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 11fc45: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fc48: 50 push %eax <== NOT EXECUTED 11fc49: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fc4e: 68 b0 a2 15 00 push $0x15a2b0 <== NOT EXECUTED 11fc53: 68 78 a3 15 00 push $0x15a378 <== NOT EXECUTED 11fc58: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11fc5b: e8 ba ff ff ff call 11fc1a <== NOT EXECUTED 11fc60: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fc63: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fc65: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc67: 75 03 jne 11fc6c <== NOT EXECUTED return NULL; return p; 11fc69: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fc6c: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fc6e: c9 leave <== NOT EXECUTED 11fc6f: c3 ret <== NOT EXECUTED 0011fc1a : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 11fc1a: 55 push %ebp <== NOT EXECUTED 11fc1b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc1d: 53 push %ebx <== NOT EXECUTED 11fc1e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11fc21: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fc24: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 11fc27: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 11fc2a: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 11fc2d: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11fc30: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11fc33: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fc36: 31 d2 xor %edx,%edx <== NOT EXECUTED } 11fc38: 5b pop %ebx <== NOT EXECUTED 11fc39: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(name, 0, grp, buffer, bufsize, result); 11fc3a: e9 d0 fe ff ff jmp 11fb0f <== NOT EXECUTED 0011ddf0 : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 11ddf0: 55 push %ebp <== NOT EXECUTED 11ddf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 11ddf3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11ddf8: c9 leave <== NOT EXECUTED 11ddf9: c3 ret <== NOT EXECUTED 0011fcab : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fcab: 55 push %ebp <== NOT EXECUTED 11fcac: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fcae: 57 push %edi <== NOT EXECUTED 11fcaf: 56 push %esi <== NOT EXECUTED 11fcb0: 53 push %ebx <== NOT EXECUTED 11fcb1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fcb4: 89 c7 mov %eax,%edi <== NOT EXECUTED 11fcb6: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 11fcb9: 89 ce mov %ecx,%esi <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 11fcbb: e8 43 fd ff ff call 11fa03 <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 11fcc0: 50 push %eax <== NOT EXECUTED 11fcc1: 50 push %eax <== NOT EXECUTED 11fcc2: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fcc7: 68 95 dc 13 00 push $0x13dc95 <== NOT EXECUTED 11fccc: e8 33 c0 00 00 call 12bd04 <== NOT EXECUTED 11fcd1: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fcd3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fcd6: 85 c0 test %eax,%eax <== NOT EXECUTED 11fcd8: 75 10 jne 11fcea <== NOT EXECUTED errno = EINVAL; 11fcda: e8 6d b7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11fcdf: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11fce5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fce8: eb 6b jmp 11fd55 <== NOT EXECUTED return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 11fcea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fced: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11fcf0: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11fcf3: 89 f2 mov %esi,%edx <== NOT EXECUTED 11fcf5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11fcf7: e8 d4 fb ff ff call 11f8d0 <== NOT EXECUTED 11fcfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fcff: 85 c0 test %eax,%eax <== NOT EXECUTED 11fd01: 75 19 jne 11fd1c <== NOT EXECUTED errno = EINVAL; 11fd03: e8 44 b7 00 00 call 12b44c <__errno> <== NOT EXECUTED 11fd08: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 11fd0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fd11: 53 push %ebx <== NOT EXECUTED 11fd12: e8 81 b8 00 00 call 12b598 <== NOT EXECUTED 11fd17: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11fd1a: eb 36 jmp 11fd52 <== NOT EXECUTED return -1; } if (name) { 11fd1c: 85 ff test %edi,%edi <== NOT EXECUTED 11fd1e: 74 11 je 11fd31 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); 11fd20: 50 push %eax <== NOT EXECUTED 11fd21: 50 push %eax <== NOT EXECUTED 11fd22: 57 push %edi <== NOT EXECUTED 11fd23: ff 36 pushl (%esi) <== NOT EXECUTED 11fd25: e8 66 fb 00 00 call 12f890 <== NOT EXECUTED 11fd2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fd2d: 85 c0 test %eax,%eax <== NOT EXECUTED 11fd2f: eb 07 jmp 11fd38 <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); 11fd31: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 11fd35: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 11fd38: 0f 94 c0 sete %al <== NOT EXECUTED 11fd3b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 11fd3e: 85 c0 test %eax,%eax <== NOT EXECUTED 11fd40: 74 a8 je 11fcea <== NOT EXECUTED fclose(fp); 11fd42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fd45: 53 push %ebx <== NOT EXECUTED 11fd46: e8 4d b8 00 00 call 12b598 <== NOT EXECUTED *result = pwd; 11fd4b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11fd4e: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11fd50: 31 c0 xor %eax,%eax <== NOT EXECUTED 11fd52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 11fd55: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11fd58: 5b pop %ebx <== NOT EXECUTED 11fd59: 5e pop %esi <== NOT EXECUTED 11fd5a: 5f pop %edi <== NOT EXECUTED 11fd5b: c9 leave <== NOT EXECUTED 11fd5c: c3 ret <== NOT EXECUTED 0011f9cb : return NULL; return p; } struct passwd *getpwent() { 11f9cb: 55 push %ebp <== NOT EXECUTED 11f9cc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f9ce: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 11f9d1: a1 c4 a1 15 00 mov 0x15a1c4,%eax <== NOT EXECUTED 11f9d6: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9d8: 74 23 je 11f9fd <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 11f9da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f9dd: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11f9e2: b9 c8 a1 15 00 mov $0x15a1c8,%ecx <== NOT EXECUTED 11f9e7: ba 90 a2 15 00 mov $0x15a290,%edx <== NOT EXECUTED 11f9ec: e8 df fe ff ff call 11f8d0 <== NOT EXECUTED 11f9f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f9f4: ba 90 a2 15 00 mov $0x15a290,%edx <== NOT EXECUTED 11f9f9: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9fb: 75 02 jne 11f9ff <== NOT EXECUTED 11f9fd: 31 d2 xor %edx,%edx <== NOT EXECUTED return NULL; return &pwent; } 11f9ff: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fa01: c9 leave <== NOT EXECUTED 11fa02: c3 ret <== NOT EXECUTED 0011fddb : } struct passwd *getpwnam( const char *name ) { 11fddb: 55 push %ebp <== NOT EXECUTED 11fddc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fdde: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 11fde1: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fde4: 50 push %eax <== NOT EXECUTED 11fde5: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fdea: 68 c8 a1 15 00 push $0x15a1c8 <== NOT EXECUTED 11fdef: 68 90 a2 15 00 push $0x15a290 <== NOT EXECUTED 11fdf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11fdf7: e8 ba ff ff ff call 11fdb6 <== NOT EXECUTED 11fdfc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fdff: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fe01: 85 c0 test %eax,%eax <== NOT EXECUTED 11fe03: 75 03 jne 11fe08 <== NOT EXECUTED return NULL; return p; 11fe05: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fe08: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fe0a: c9 leave <== NOT EXECUTED 11fe0b: c3 ret <== NOT EXECUTED 0011fdb6 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fdb6: 55 push %ebp <== NOT EXECUTED 11fdb7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fdb9: 53 push %ebx <== NOT EXECUTED 11fdba: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11fdbd: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fdc0: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 11fdc3: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 11fdc6: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 11fdc9: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11fdcc: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11fdcf: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fdd2: 31 d2 xor %edx,%edx <== NOT EXECUTED } 11fdd4: 5b pop %ebx <== NOT EXECUTED 11fdd5: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(name, 0, pwd, buffer, bufsize, result); 11fdd6: e9 d0 fe ff ff jmp 11fcab <== NOT EXECUTED 0011fd83 : } struct passwd *getpwuid( uid_t uid ) { 11fd83: 55 push %ebp <== NOT EXECUTED 11fd84: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fd86: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 11fd89: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11fd8c: 50 push %eax <== NOT EXECUTED 11fd8d: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 11fd92: 68 c8 a1 15 00 push $0x15a1c8 <== NOT EXECUTED 11fd97: 68 90 a2 15 00 push $0x15a290 <== NOT EXECUTED 11fd9c: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 11fda0: 50 push %eax <== NOT EXECUTED 11fda1: e8 b7 ff ff ff call 11fd5d <== NOT EXECUTED 11fda6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11fda9: 31 d2 xor %edx,%edx <== NOT EXECUTED 11fdab: 85 c0 test %eax,%eax <== NOT EXECUTED 11fdad: 75 03 jne 11fdb2 <== NOT EXECUTED return NULL; return p; 11fdaf: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED } 11fdb2: 89 d0 mov %edx,%eax <== NOT EXECUTED 11fdb4: c9 leave <== NOT EXECUTED 11fdb5: c3 ret <== NOT EXECUTED 0011fd5d : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 11fd5d: 55 push %ebp <== NOT EXECUTED 11fd5e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fd60: 53 push %ebx <== NOT EXECUTED 11fd61: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11fd64: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 11fd67: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 11fd6b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11fd6e: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11fd71: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11fd74: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11fd77: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 11fd7a: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11fd7c: 5b pop %ebx <== NOT EXECUTED 11fd7d: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 11fd7e: e9 28 ff ff ff jmp 11fcab <== NOT EXECUTED 0010cde4 : int gettimeofday( struct timeval *tp, void * __tz ) { 10cde4: 55 push %ebp <== NOT EXECUTED 10cde5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cde7: 56 push %esi <== NOT EXECUTED 10cde8: 53 push %ebx <== NOT EXECUTED 10cde9: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10cdec: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10cdef: 85 f6 test %esi,%esi <== NOT EXECUTED 10cdf1: 75 10 jne 10ce03 <== NOT EXECUTED errno = EFAULT; 10cdf3: e8 c0 22 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10cdf8: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10cdfe: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10ce01: eb 2a jmp 10ce2d <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10ce03: 9c pushf <== NOT EXECUTED 10ce04: fa cli <== NOT EXECUTED 10ce05: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10ce06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce09: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ce0c: 50 push %eax <== NOT EXECUTED 10ce0d: e8 fe d0 ff ff call 109f10 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 10ce12: 53 push %ebx <== NOT EXECUTED 10ce13: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 10ce14: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ce17: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 10ce19: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10ce1c: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 10ce21: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ce23: f7 f1 div %ecx <== NOT EXECUTED 10ce25: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10ce28: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ce2a: 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; } 10ce2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ce30: 5b pop %ebx <== NOT EXECUTED 10ce31: 5e pop %esi <== NOT EXECUTED 10ce32: c9 leave <== NOT EXECUTED 10ce33: 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 a4 4b 14 00 mov 0x144ba4,%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 00129437 : */ int imfs_dir_close( rtems_libio_t *iop ) { 129437: 55 push %ebp <== NOT EXECUTED 129438: 89 e5 mov %esp,%ebp <== NOT EXECUTED * and associated memory. At present the imfs_dir_close simply * returns a successful completion status. */ return 0; } 12943a: 31 c0 xor %eax,%eax <== NOT EXECUTED 12943c: c9 leave <== NOT EXECUTED 12943d: c3 ret <== NOT EXECUTED 0012943e : int imfs_dir_fstat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 12943e: 55 push %ebp <== NOT EXECUTED 12943f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129441: 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; 129444: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129447: 8b 10 mov (%eax),%edx <== NOT EXECUTED buf->st_dev = 0ll; 129449: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 12944f: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 129456: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 129459: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED buf->st_mode = the_jnode->st_mode; 12945c: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12945f: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 129462: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 129465: 66 89 41 10 mov %ax,0x10(%ecx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 129469: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 12946c: 66 89 41 12 mov %ax,0x12(%ecx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 129470: 66 8b 42 3e mov 0x3e(%edx),%ax <== NOT EXECUTED 129474: 66 89 41 14 mov %ax,0x14(%ecx) <== NOT EXECUTED buf->st_rdev = 0ll; 129478: c7 41 18 00 00 00 00 movl $0x0,0x18(%ecx) <== NOT EXECUTED 12947f: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED buf->st_blksize = 0; 129486: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED buf->st_blocks = 0; 12948d: c7 41 40 00 00 00 00 movl $0x0,0x40(%ecx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 129494: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 129497: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 12949a: 8b 42 44 mov 0x44(%edx),%eax <== NOT EXECUTED 12949d: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 1294a0: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 1294a3: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED buf->st_size = 0; 1294a6: 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 ; 1294ad: 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 1294b0: 83 c2 54 add $0x54,%edx <== NOT EXECUTED 1294b3: eb 09 jmp 1294be <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ) ; the_node = the_node->next ) { buf->st_size = buf->st_size + sizeof( struct dirent ); 1294b5: 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 ) { 1294bc: 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 ) ; 1294be: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1294c0: 75 f3 jne 1294b5 <== NOT EXECUTED buf->st_size = buf->st_size + sizeof( struct dirent ); } return 0; } 1294c2: 31 c0 xor %eax,%eax <== NOT EXECUTED 1294c4: c9 leave <== NOT EXECUTED 1294c5: c3 ret <== NOT EXECUTED 001294c6 : off_t imfs_dir_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 1294c6: 55 push %ebp <== NOT EXECUTED 1294c7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1294c9: 53 push %ebx <== NOT EXECUTED 1294ca: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1294cd: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED switch( whence ) { 1294d0: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 1294d4: 77 19 ja 1294ef <== 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)) * 1294d6: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 1294d9: bb 0c 01 00 00 mov $0x10c,%ebx <== NOT EXECUTED 1294de: 31 d2 xor %edx,%edx <== NOT EXECUTED 1294e0: f7 f3 div %ebx <== NOT EXECUTED 1294e2: 69 c0 0c 01 00 00 imul $0x10c,%eax,%eax <== NOT EXECUTED 1294e8: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED 1294eb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1294ed: eb 0e jmp 1294fd <== 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 ); 1294ef: e8 58 1f 00 00 call 12b44c <__errno> <== NOT EXECUTED 1294f4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1294fa: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED break; } return 0; } 1294fd: 5a pop %edx <== NOT EXECUTED 1294fe: 5b pop %ebx <== NOT EXECUTED 1294ff: c9 leave <== NOT EXECUTED 129500: c3 ret <== NOT EXECUTED 00129418 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 129418: 55 push %ebp <== NOT EXECUTED 129419: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12941b: 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 ) 12941e: 8b 41 2c mov 0x2c(%ecx),%eax <== NOT EXECUTED 129421: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 129424: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 129428: 75 09 jne 129433 <== NOT EXECUTED return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 12942a: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 129431: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 129433: 89 d0 mov %edx,%eax <== NOT EXECUTED 129435: c9 leave <== NOT EXECUTED 129436: c3 ret <== NOT EXECUTED 001295b4 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 1295b4: 55 push %ebp <== NOT EXECUTED 1295b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1295b7: 57 push %edi <== NOT EXECUTED 1295b8: 56 push %esi <== NOT EXECUTED 1295b9: 53 push %ebx <== NOT EXECUTED 1295ba: 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; 1295c0: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1295c3: 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( 1295c6: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 1295c9: 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 1295cf: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 1295d2: 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 ) ) 1295d8: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 1295df: 00 00 00 <== NOT EXECUTED 1295e2: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1295e4: 0f 84 ef 00 00 00 je 1296d9 <== NOT EXECUTED /* Move to the first of the desired directory entries */ the_node = the_chain->first; bytes_transferred = 0; first_entry = iop->offset; 1295ea: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1295ed: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED 1295f0: 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); 1295f6: b9 0c 01 00 00 mov $0x10c,%ecx <== NOT EXECUTED 1295fb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1295fe: 31 d2 xor %edx,%edx <== NOT EXECUTED 129600: f7 f1 div %ecx <== NOT EXECUTED 129602: 69 c0 0c 01 00 00 imul $0x10c,%eax,%eax <== NOT EXECUTED 129608: 01 f8 add %edi,%eax <== NOT EXECUTED 12960a: 89 85 dc fe ff ff mov %eax,-0x124(%ebp) <== NOT EXECUTED 129610: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 129617: 00 00 00 <== NOT EXECUTED 12961a: 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 ); 12961c: 8d 95 e8 fe ff ff lea -0x118(%ebp),%edx <== NOT EXECUTED 129622: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) <== NOT EXECUTED 129628: e9 a0 00 00 00 jmp 1296cd <== 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 ) ){ 12962d: 8b b5 e0 fe ff ff mov -0x120(%ebp),%esi <== NOT EXECUTED 129633: 39 b5 c0 fe ff ff cmp %esi,-0x140(%ebp) <== NOT EXECUTED 129639: 0f 84 9a 00 00 00 je 1296d9 <== NOT EXECUTED /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 12963f: 3b 9d d8 fe ff ff cmp -0x128(%ebp),%ebx <== NOT EXECUTED 129645: 7c 72 jl 1296b9 <== NOT EXECUTED /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 129647: 89 9d ec fe ff ff mov %ebx,-0x114(%ebp) <== NOT EXECUTED tmp_dirent.d_reclen = sizeof( struct dirent ); 12964d: 66 c7 85 f0 fe ff ff movw $0x10c,-0x110(%ebp) <== NOT EXECUTED 129654: 0c 01 <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 129656: 8b bd c0 fe ff ff mov -0x140(%ebp),%edi <== NOT EXECUTED 12965c: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12965f: 89 85 e8 fe ff ff mov %eax,-0x118(%ebp) <== NOT EXECUTED tmp_dirent.d_namlen = strlen( the_jnode->name ); 129665: 89 fa mov %edi,%edx <== NOT EXECUTED 129667: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 12966a: 31 c0 xor %eax,%eax <== NOT EXECUTED 12966c: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 12966f: 89 d7 mov %edx,%edi <== NOT EXECUTED 129671: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 129673: f7 d1 not %ecx <== NOT EXECUTED 129675: 49 dec %ecx <== NOT EXECUTED 129676: 66 89 8d f2 fe ff ff mov %cx,-0x10e(%ebp) <== NOT EXECUTED strcpy( tmp_dirent.d_name, the_jnode->name ); 12967d: 56 push %esi <== NOT EXECUTED 12967e: 56 push %esi <== NOT EXECUTED 12967f: 52 push %edx <== NOT EXECUTED 129680: 8d 85 f4 fe ff ff lea -0x10c(%ebp),%eax <== NOT EXECUTED 129686: 50 push %eax <== NOT EXECUTED 129687: e8 68 62 00 00 call 12f8f4 <== NOT EXECUTED memcpy( 12968c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 12968f: 03 bd d4 fe ff ff add -0x12c(%ebp),%edi <== NOT EXECUTED 129695: b9 43 00 00 00 mov $0x43,%ecx <== NOT EXECUTED 12969a: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi <== NOT EXECUTED 1296a0: 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); 1296a2: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1296a5: 81 47 08 0c 01 00 00 addl $0x10c,0x8(%edi) <== NOT EXECUTED bytes_transferred = bytes_transferred + sizeof( struct dirent ); 1296ac: 81 85 d4 fe ff ff 0c addl $0x10c,-0x12c(%ebp) <== NOT EXECUTED 1296b3: 01 00 00 <== NOT EXECUTED 1296b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } the_node = the_node->next; 1296b9: 8b 85 c0 fe ff ff mov -0x140(%ebp),%eax <== NOT EXECUTED 1296bf: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1296c1: 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 ) { 1296c7: 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; 1296cd: 3b 9d dc fe ff ff cmp -0x124(%ebp),%ebx <== NOT EXECUTED 1296d3: 0f 8c 54 ff ff ff jl 12962d <== NOT EXECUTED the_node = the_node->next; } /* Success */ return bytes_transferred; } 1296d9: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax <== NOT EXECUTED 1296df: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1296e2: 5b pop %ebx <== NOT EXECUTED 1296e3: 5e pop %esi <== NOT EXECUTED 1296e4: 5f pop %edi <== NOT EXECUTED 1296e5: c9 leave <== NOT EXECUTED 1296e6: c3 ret <== NOT EXECUTED 00129501 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 129501: 55 push %ebp <== NOT EXECUTED 129502: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129504: 56 push %esi <== NOT EXECUTED 129505: 53 push %ebx <== NOT EXECUTED 129506: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 129509: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 12950c: 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 ) ) 12950e: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 129511: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 129514: 74 0d je 129523 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 129516: e8 31 1f 00 00 call 12b44c <__errno> <== NOT EXECUTED 12951b: c7 00 5a 00 00 00 movl $0x5a,(%eax) <== NOT EXECUTED 129521: eb 19 jmp 12953c <== NOT EXECUTED /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 129523: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 129526: 39 58 18 cmp %ebx,0x18(%eax) <== NOT EXECUTED 129529: 74 06 je 129531 <== NOT EXECUTED /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 12952b: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) <== NOT EXECUTED 12952f: 74 10 je 129541 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); 129531: e8 16 1f 00 00 call 12b44c <__errno> <== NOT EXECUTED 129536: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 12953c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 12953f: eb 6c jmp 1295ad <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 129541: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 129545: 74 13 je 12955a <== NOT EXECUTED 129547: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12954a: 53 push %ebx <== NOT EXECUTED 12954b: e8 a8 4c fe ff call 10e1f8 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 129550: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 129557: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 12955a: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 12955e: 51 push %ecx <== NOT EXECUTED 12955f: 51 push %ecx <== NOT EXECUTED 129560: 6a 00 push $0x0 <== NOT EXECUTED 129562: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 129565: 50 push %eax <== NOT EXECUTED 129566: e8 29 0b fe ff call 10a094 <== NOT EXECUTED 12956b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12956e: 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) ) { 129571: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 129574: e8 77 0c fe ff call 10a1f0 <== NOT EXECUTED 129579: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12957c: 85 c0 test %eax,%eax <== NOT EXECUTED 12957e: 75 2b jne 1295ab <== NOT EXECUTED 129580: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 129585: 75 24 jne 1295ab <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 129587: 8b 15 a4 4b 14 00 mov 0x144ba4,%edx <== NOT EXECUTED 12958d: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 129590: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 129592: 75 07 jne 12959b <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 129594: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 12959b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12959e: 53 push %ebx <== NOT EXECUTED 12959f: e8 78 0a fe ff call 10a01c <== NOT EXECUTED 1295a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1295a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1295a9: eb 02 jmp 1295ad <== NOT EXECUTED 1295ab: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 1295ad: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1295b0: 5b pop %ebx <== NOT EXECUTED 1295b1: 5e pop %esi <== NOT EXECUTED 1295b2: c9 leave <== NOT EXECUTED 1295b3: c3 ret <== NOT EXECUTED 0011fa03 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 11fa03: 55 push %ebp <== NOT EXECUTED 11fa04: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fa06: 53 push %ebx <== NOT EXECUTED 11fa07: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 11fa0a: 80 3d c0 a1 15 00 00 cmpb $0x0,0x15a1c0 <== NOT EXECUTED 11fa11: 0f 85 b8 00 00 00 jne 11facf <== NOT EXECUTED return; etc_passwd_initted = 1; 11fa17: c6 05 c0 a1 15 00 01 movb $0x1,0x15a1c0 <== NOT EXECUTED mkdir("/etc", 0777); 11fa1e: 51 push %ecx <== NOT EXECUTED 11fa1f: 51 push %ecx <== NOT EXECUTED 11fa20: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 11fa25: 68 90 dc 13 00 push $0x13dc90 <== NOT EXECUTED 11fa2a: e8 e9 ab fe ff call 10a618 <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 11fa2f: 58 pop %eax <== NOT EXECUTED 11fa30: 5a pop %edx <== NOT EXECUTED 11fa31: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fa36: 68 95 dc 13 00 push $0x13dc95 <== NOT EXECUTED 11fa3b: e8 c4 c2 00 00 call 12bd04 <== NOT EXECUTED 11fa40: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fa43: 85 c0 test %eax,%eax <== NOT EXECUTED 11fa45: 74 06 je 11fa4d <== NOT EXECUTED fclose(fp); 11fa47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fa4a: 50 push %eax <== NOT EXECUTED 11fa4b: eb 2a jmp 11fa77 <== NOT EXECUTED } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 11fa4d: 50 push %eax <== NOT EXECUTED 11fa4e: 50 push %eax <== NOT EXECUTED 11fa4f: 68 9e bc 13 00 push $0x13bc9e <== NOT EXECUTED 11fa54: 68 95 dc 13 00 push $0x13dc95 <== NOT EXECUTED 11fa59: e8 a6 c2 00 00 call 12bd04 <== NOT EXECUTED 11fa5e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fa60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fa63: 85 c0 test %eax,%eax <== NOT EXECUTED 11fa65: 74 18 je 11fa7f <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 11fa67: 50 push %eax <== NOT EXECUTED 11fa68: 50 push %eax <== NOT EXECUTED 11fa69: 53 push %ebx <== NOT EXECUTED 11fa6a: 68 a1 dc 13 00 push $0x13dca1 <== NOT EXECUTED 11fa6f: e8 b8 c3 00 00 call 12be2c <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 11fa74: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11fa77: e8 1c bb 00 00 call 12b598 <== NOT EXECUTED 11fa7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 11fa7f: 53 push %ebx <== NOT EXECUTED 11fa80: 53 push %ebx <== NOT EXECUTED 11fa81: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fa86: 68 08 dd 13 00 push $0x13dd08 <== NOT EXECUTED 11fa8b: e8 74 c2 00 00 call 12bd04 <== NOT EXECUTED 11fa90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fa93: 85 c0 test %eax,%eax <== NOT EXECUTED 11fa95: 74 06 je 11fa9d <== NOT EXECUTED fclose(fp); 11fa97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fa9a: 50 push %eax <== NOT EXECUTED 11fa9b: eb 2a jmp 11fac7 <== NOT EXECUTED } else if ((fp = fopen("/etc/group", "w")) != NULL) { 11fa9d: 51 push %ecx <== NOT EXECUTED 11fa9e: 51 push %ecx <== NOT EXECUTED 11fa9f: 68 9e bc 13 00 push $0x13bc9e <== NOT EXECUTED 11faa4: 68 08 dd 13 00 push $0x13dd08 <== NOT EXECUTED 11faa9: e8 56 c2 00 00 call 12bd04 <== NOT EXECUTED 11faae: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11fab0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11fab3: 85 c0 test %eax,%eax <== NOT EXECUTED 11fab5: 74 18 je 11facf <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 11fab7: 52 push %edx <== NOT EXECUTED 11fab8: 52 push %edx <== NOT EXECUTED 11fab9: 50 push %eax <== NOT EXECUTED 11faba: 68 13 dd 13 00 push $0x13dd13 <== NOT EXECUTED 11fabf: e8 68 c3 00 00 call 12be2c <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 11fac4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11fac7: e8 cc ba 00 00 call 12b598 <== NOT EXECUTED 11facc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 11facf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11fad2: c9 leave <== NOT EXECUTED 11fad3: c3 ret <== NOT EXECUTED 0010d084 : * This routine will initialize the chain control element that manages the * mount table chain. */ int init_fs_mount_table(void) { 10d084: 55 push %ebp <== NOT EXECUTED 10d085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d087: c7 05 10 dc 11 00 14 movl $0x11dc14,0x11dc10 <== NOT EXECUTED 10d08e: dc 11 00 <== NOT EXECUTED 10d091: c7 05 14 dc 11 00 00 movl $0x0,0x11dc14 <== NOT EXECUTED 10d098: 00 00 00 <== NOT EXECUTED 10d09b: c7 05 18 dc 11 00 10 movl $0x11dc10,0x11dc18 <== NOT EXECUTED 10d0a2: dc 11 00 <== NOT EXECUTED rtems_chain_initialize_empty ( &rtems_filesystem_mount_table_control ); return 0; } 10d0a5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d0a7: c9 leave <== NOT EXECUTED 10d0a8: c3 ret <== NOT EXECUTED 0011535c : int ioctl( int fd, ioctl_command_t command, ... ) { 11535c: 55 push %ebp <== NOT EXECUTED 11535d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11535f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115362: 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 ); 115365: 3b 05 98 43 12 00 cmp 0x124398,%eax <== NOT EXECUTED 11536b: 73 19 jae 115386 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11536d: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 115370: 03 05 fc 97 12 00 add 0x1297fc,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 115376: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 11537a: 74 0a je 115386 <== NOT EXECUTED va_start(ap, command); buffer = va_arg(ap, void *); 11537c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) 11537f: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 115382: 85 d2 test %edx,%edx <== NOT EXECUTED 115384: 75 0d jne 115393 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 115386: e8 b1 08 00 00 call 115c3c <__errno> <== NOT EXECUTED 11538b: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 115391: eb 12 jmp 1153a5 <== NOT EXECUTED if ( !iop->handlers->ioctl_h ) 115393: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 115396: 85 d2 test %edx,%edx <== NOT EXECUTED 115398: 75 10 jne 1153aa <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11539a: e8 9d 08 00 00 call 115c3c <__errno> <== NOT EXECUTED 11539f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1153a5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1153a8: eb 0d jmp 1153b7 <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 1153aa: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1153ad: 51 push %ecx <== NOT EXECUTED 1153ae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1153b1: 50 push %eax <== NOT EXECUTED 1153b2: ff d2 call *%edx <== NOT EXECUTED 1153b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 1153b7: c9 leave <== NOT EXECUTED 1153b8: 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 e0 b5 11 00 mov 0x11b5e0,%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 1c b5 11 00 mov 0x11b51c,%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 0011556c : #include int isatty( int fd ) { 11556c: 55 push %ebp <== NOT EXECUTED 11556d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11556f: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat buf; if (fstat (fd, &buf) < 0) 115572: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 115575: 50 push %eax <== NOT EXECUTED 115576: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115579: e8 4a ff ff ff call 1154c8 <== NOT EXECUTED 11557e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115581: 31 d2 xor %edx,%edx <== NOT EXECUTED 115583: 85 c0 test %eax,%eax <== NOT EXECUTED 115585: 78 12 js 115599 <== NOT EXECUTED 115587: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 11558a: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 11558f: 31 d2 xor %edx,%edx <== NOT EXECUTED 115591: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 115596: 0f 94 c2 sete %dl <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 115599: 89 d0 mov %edx,%eax <== NOT EXECUTED 11559b: c9 leave <== NOT EXECUTED 11559c: c3 ret <== NOT EXECUTED 0010916c : int kill( pid_t pid, int sig ) { 10916c: 55 push %ebp <== NOT EXECUTED 10916d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10916f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, sig, NULL ); 109172: 6a 00 push $0x0 <== NOT EXECUTED 109174: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109177: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10917a: e8 e9 55 00 00 call 10e768 <== NOT EXECUTED } 10917f: c9 leave <== NOT EXECUTED 109180: c3 ret <== NOT EXECUTED 0011e06c : int killinfo( pid_t pid, int sig, const union sigval *value ) { 11e06c: 55 push %ebp <== NOT EXECUTED 11e06d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e06f: 57 push %edi <== NOT EXECUTED 11e070: 56 push %esi <== NOT EXECUTED 11e071: 53 push %ebx <== NOT EXECUTED 11e072: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 11e075: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 11e078: e8 73 fd ff ff call 11ddf0 <== NOT EXECUTED 11e07d: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 11e080: 74 0d je 11e08f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); 11e082: e8 b5 7b ff ff call 115c3c <__errno> <== NOT EXECUTED 11e087: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 11e08d: eb 11 jmp 11e0a0 <== NOT EXECUTED /* * Validate the signal passed. */ if ( !sig ) 11e08f: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11e093: 75 13 jne 11e0a8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 11e095: e8 a2 7b ff ff call 115c3c <__errno> <== NOT EXECUTED 11e09a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11e0a0: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11e0a3: e9 05 02 00 00 jmp 11e2ad <== NOT EXECUTED if ( !is_valid_signo(sig) ) 11e0a8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11e0ab: 49 dec %ecx <== NOT EXECUTED 11e0ac: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 11e0af: 77 e4 ja 11e095 <== NOT EXECUTED /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 11e0b1: 6b 45 0c 0c imul $0xc,0xc(%ebp),%eax <== NOT EXECUTED 11e0b5: 31 d2 xor %edx,%edx <== NOT EXECUTED 11e0b7: 83 b8 80 9f 12 00 01 cmpl $0x1,0x129f80(%eax) <== NOT EXECUTED 11e0be: 0f 84 e9 01 00 00 je 11e2ad <== NOT EXECUTED * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 11e0c4: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) <== NOT EXECUTED 11e0c8: 74 0c je 11e0d6 <== NOT EXECUTED 11e0ca: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) <== NOT EXECUTED 11e0ce: 74 06 je 11e0d6 <== NOT EXECUTED 11e0d0: 83 7d 0c 0b cmpl $0xb,0xc(%ebp) <== NOT EXECUTED 11e0d4: 75 1a jne 11e0f0 <== NOT EXECUTED return pthread_kill( pthread_self(), sig ); 11e0d6: e8 9d 03 00 00 call 11e478 <== NOT EXECUTED 11e0db: 53 push %ebx <== NOT EXECUTED 11e0dc: 53 push %ebx <== NOT EXECUTED 11e0dd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11e0e0: 50 push %eax <== NOT EXECUTED 11e0e1: e8 e6 02 00 00 call 11e3cc <== NOT EXECUTED 11e0e6: 89 c2 mov %eax,%edx <== NOT EXECUTED 11e0e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e0eb: e9 bd 01 00 00 jmp 11e2ad <== NOT EXECUTED mask = signo_to_mask( sig ); 11e0f0: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 11e0f5: d3 e3 shl %cl,%ebx <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 11e0f7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11e0fa: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED siginfo->si_code = SI_USER; 11e0fd: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) <== NOT EXECUTED if ( !value ) { 11e104: 85 f6 test %esi,%esi <== NOT EXECUTED 11e106: 75 09 jne 11e111 <== NOT EXECUTED siginfo->si_value.sival_int = 0; 11e108: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 11e10f: eb 05 jmp 11e116 <== NOT EXECUTED } else { siginfo->si_value = *value; 11e111: 8b 06 mov (%esi),%eax <== NOT EXECUTED 11e113: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11e116: a1 5c 99 12 00 mov 0x12995c,%eax <== NOT EXECUTED 11e11b: 40 inc %eax <== NOT EXECUTED 11e11c: a3 5c 99 12 00 mov %eax,0x12995c <== NOT EXECUTED /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 11e121: 8b 35 1c 9a 12 00 mov 0x129a1c,%esi <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 11e127: 8b 86 f8 00 00 00 mov 0xf8(%esi),%eax <== NOT EXECUTED 11e12d: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 11e133: f7 d0 not %eax <== NOT EXECUTED 11e135: 85 c3 test %eax,%ebx <== NOT EXECUTED 11e137: 0f 85 f4 00 00 00 jne 11e231 <== NOT EXECUTED goto process_it; 11e13d: b9 04 a1 12 00 mov $0x12a104,%ecx <== NOT EXECUTED index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 11e142: 8b 11 mov (%ecx),%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 11e144: 8d 79 04 lea 0x4(%ecx),%edi <== NOT EXECUTED 11e147: eb 23 jmp 11e16c <== NOT EXECUTED !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 11e149: 89 d6 mov %edx,%esi <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11e14b: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 11e151: 85 5a 30 test %ebx,0x30(%edx) <== NOT EXECUTED 11e154: 0f 85 d7 00 00 00 jne 11e231 <== NOT EXECUTED 11e15a: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 11e160: f7 d0 not %eax <== NOT EXECUTED 11e162: 85 c3 test %eax,%ebx <== NOT EXECUTED 11e164: 0f 85 c7 00 00 00 jne 11e231 <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 11e16a: 8b 12 mov (%edx),%edx <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 11e16c: 39 fa cmp %edi,%edx <== NOT EXECUTED 11e16e: 75 d9 jne 11e149 <== NOT EXECUTED 11e170: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 11e173: 81 f9 34 a1 12 00 cmp $0x12a134,%ecx <== NOT EXECUTED 11e179: 75 c7 jne 11e142 <== NOT EXECUTED * * + rtems internal threads do not receive signals. */ interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 11e17b: 0f b6 05 44 44 12 00 movzbl 0x124444,%eax <== NOT EXECUTED 11e182: 40 inc %eax <== NOT EXECUTED 11e183: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 11e186: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp) <== NOT EXECUTED 11e18d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED the_api++ ) { /* * Thie can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 11e194: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 11e197: 8b 04 95 30 99 12 00 mov 0x129930(,%edx,4),%eax <== NOT EXECUTED 11e19e: 85 c0 test %eax,%eax <== NOT EXECUTED 11e1a0: 74 79 je 11e21b <== NOT EXECUTED continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 11e1a2: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED /* * This cannot happen in the current (as of Dec 2007) implementation * of initialization but at some point, the object information * structure for a particular manager may not be installed. */ if ( !the_info ) 11e1a5: 85 c0 test %eax,%eax <== NOT EXECUTED 11e1a7: 74 72 je 11e21b <== NOT EXECUTED continue; maximum = the_info->maximum; 11e1a9: 0f b7 50 10 movzwl 0x10(%eax),%edx <== NOT EXECUTED 11e1ad: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED object_table = the_info->local_table; 11e1b0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11e1b3: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 11e1b6: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 11e1bb: eb 59 jmp 11e216 <== NOT EXECUTED for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 11e1bd: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11e1c0: 8b 14 b8 mov (%eax,%edi,4),%edx <== NOT EXECUTED if ( !the_thread ) 11e1c3: 85 d2 test %edx,%edx <== NOT EXECUTED 11e1c5: 74 43 je 11e20a <== NOT EXECUTED /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 11e1c7: 8b 72 14 mov 0x14(%edx),%esi <== NOT EXECUTED 11e1ca: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 11e1cd: 77 3b ja 11e20a <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11e1cf: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 11e1d5: 85 c0 test %eax,%eax <== NOT EXECUTED 11e1d7: 74 31 je 11e20a <== NOT EXECUTED 11e1d9: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 11e1df: f7 d0 not %eax <== NOT EXECUTED 11e1e1: 85 c3 test %eax,%ebx <== NOT EXECUTED 11e1e3: 74 25 je 11e20a <== NOT EXECUTED * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 11e1e5: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 11e1e8: 72 25 jb 11e20f <== NOT EXECUTED * Now the thread and the interested thread have the same priority. * If the interested thread is ready, then we don't need to send it * to a blocked thread. */ if ( _States_Is_ready( interested_thread->current_state ) ) 11e1ea: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11e1ed: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED 11e1f0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11e1f2: 74 16 je 11e20a <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 11e1f4: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 11e1f7: 85 c0 test %eax,%eax <== NOT EXECUTED 11e1f9: 74 14 je 11e20f <== NOT EXECUTED * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 11e1fb: 81 e1 00 00 00 10 and $0x10000000,%ecx <== NOT EXECUTED 11e201: 75 07 jne 11e20a <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 11e203: a9 00 00 00 10 test $0x10000000,%eax <== NOT EXECUTED 11e208: 75 05 jne 11e20f <== NOT EXECUTED 11e20a: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 11e20d: eb 03 jmp 11e212 <== NOT EXECUTED 11e20f: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 11e212: 47 inc %edi <== NOT EXECUTED 11e213: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED 11e216: 3b 7d d4 cmp -0x2c(%ebp),%edi <== NOT EXECUTED 11e219: 76 a2 jbe 11e1bd <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 11e21b: ff 45 d0 incl -0x30(%ebp) <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; 11e21e: 83 7d d0 05 cmpl $0x5,-0x30(%ebp) <== NOT EXECUTED 11e222: 0f 85 6c ff ff ff jne 11e194 <== NOT EXECUTED interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 11e228: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED 11e22c: 74 1c je 11e24a <== NOT EXECUTED 11e22e: 8b 75 dc mov -0x24(%ebp),%esi <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 11e231: c6 46 75 01 movb $0x1,0x75(%esi) <== NOT EXECUTED /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 11e235: 51 push %ecx <== NOT EXECUTED 11e236: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 11e239: 50 push %eax <== NOT EXECUTED 11e23a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11e23d: 56 push %esi <== NOT EXECUTED 11e23e: e8 99 00 00 00 call 11e2dc <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 11e243: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e246: 84 c0 test %al,%al <== NOT EXECUTED 11e248: 75 5c jne 11e2a6 <== NOT EXECUTED /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 11e24a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e24d: 53 push %ebx <== NOT EXECUTED 11e24e: e8 65 00 00 00 call 11e2b8 <_POSIX_signals_Set_process_signals> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 11e253: 6b 5d 0c 0c imul $0xc,0xc(%ebp),%ebx <== NOT EXECUTED 11e257: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e25a: 83 bb 78 9f 12 00 02 cmpl $0x2,0x129f78(%ebx) <== NOT EXECUTED 11e261: 75 43 jne 11e2a6 <== NOT EXECUTED psiginfo = (POSIX_signals_Siginfo_node *) 11e263: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11e266: 68 f8 a0 12 00 push $0x12a0f8 <== NOT EXECUTED 11e26b: e8 dc ee fe ff call 10d14c <_Chain_Get> <== NOT EXECUTED _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 11e270: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e273: 85 c0 test %eax,%eax <== NOT EXECUTED 11e275: 75 10 jne 11e287 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 11e277: e8 c0 79 ff ff call 115c3c <__errno> <== NOT EXECUTED 11e27c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 11e282: e9 19 fe ff ff jmp 11e0a0 <== NOT EXECUTED } psiginfo->Info = *siginfo; 11e287: 8d 78 08 lea 0x8(%eax),%edi <== NOT EXECUTED 11e28a: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 11e28d: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 11e292: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 11e294: 52 push %edx <== NOT EXECUTED 11e295: 52 push %edx <== NOT EXECUTED 11e296: 50 push %eax <== NOT EXECUTED 11e297: 8d 83 48 a1 12 00 lea 0x12a148(%ebx),%eax <== NOT EXECUTED 11e29d: 50 push %eax <== NOT EXECUTED 11e29e: e8 85 ee fe ff call 10d128 <_Chain_Append> <== NOT EXECUTED 11e2a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 11e2a6: e8 1d 02 ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 11e2ab: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 11e2ad: 89 d0 mov %edx,%eax <== NOT EXECUTED 11e2af: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e2b2: 5b pop %ebx <== NOT EXECUTED 11e2b3: 5e pop %esi <== NOT EXECUTED 11e2b4: 5f pop %edi <== NOT EXECUTED 11e2b5: c9 leave <== NOT EXECUTED 11e2b6: 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 1c 55 00 00 call 10bdfd <_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 71 11 00 movl $0x117180,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 00 b6 11 00 mov 0x11b600,%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 18 b1 11 00 cmp $0x11b118,%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 1e 8f 00 00 call 10f770 <_fwalk> <== NOT EXECUTED #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 106852: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 106855: e8 8e 55 00 00 call 10bde8 <_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 00 b6 11 00 00 movl $0x0,0x11b600 <== 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 00 b6 11 00 18 movl $0x11b118,0x11b600 <== NOT EXECUTED 106806: b1 11 00 <== NOT EXECUTED 106809: c7 05 00 d7 11 00 00 movl $0x11b600,0x11d700 <== NOT EXECUTED 106810: b6 11 00 <== NOT EXECUTED _Thread_Set_libc_reent (&_REENT); } 106813: c9 leave <== NOT EXECUTED 106814: c3 ret <== NOT EXECUTED 00115664 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 115664: 55 push %ebp <== NOT EXECUTED 115665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115667: 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())) 11566a: 83 3d 18 d8 11 00 03 cmpl $0x3,0x11d818 <== NOT EXECUTED 115671: 75 55 jne 1156c8 <== NOT EXECUTED /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 115673: 81 3d 00 b6 11 00 18 cmpl $0x11b118,0x11b600 <== NOT EXECUTED 11567a: b1 11 00 <== NOT EXECUTED 11567d: 74 1a je 115699 <== NOT EXECUTED _wrapup_reent(&libc_global_reent); 11567f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115682: 68 18 b1 11 00 push $0x11b118 <== NOT EXECUTED 115687: e8 b8 05 00 00 call 115c44 <_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; 11568c: c7 05 00 b6 11 00 18 movl $0x11b118,0x11b600 <== NOT EXECUTED 115693: b1 11 00 <== NOT EXECUTED 115696: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 115699: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11569c: a1 00 b6 11 00 mov 0x11b600,%eax <== NOT EXECUTED 1156a1: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 1156a4: e8 5b 9b ff ff call 10f204 <== NOT EXECUTED fclose (stdout); 1156a9: 5a pop %edx <== NOT EXECUTED 1156aa: a1 00 b6 11 00 mov 0x11b600,%eax <== NOT EXECUTED 1156af: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1156b2: e8 4d 9b ff ff call 10f204 <== NOT EXECUTED fclose (stderr); 1156b7: 58 pop %eax <== NOT EXECUTED 1156b8: a1 00 b6 11 00 mov 0x11b600,%eax <== NOT EXECUTED 1156bd: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1156c0: e8 3f 9b ff ff call 10f204 <== NOT EXECUTED 1156c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1156c8: c9 leave <== NOT EXECUTED 1156c9: c3 ret <== NOT EXECUTED 0011fea0 : int link( const char *existing, const char *new ) { 11fea0: 55 push %ebp <== NOT EXECUTED 11fea1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fea3: 57 push %edi <== NOT EXECUTED 11fea4: 56 push %esi <== NOT EXECUTED 11fea5: 53 push %ebx <== NOT EXECUTED 11fea6: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 11fea9: 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 ); 11feac: 6a 01 push $0x1 <== NOT EXECUTED 11feae: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11feb1: 50 push %eax <== NOT EXECUTED 11feb2: 6a 00 push $0x0 <== NOT EXECUTED 11feb4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11feb7: e8 3e a0 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 11febc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11febf: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 11fec2: 85 c0 test %eax,%eax <== NOT EXECUTED 11fec4: 0f 85 7a 01 00 00 jne 120044 <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 11feca: 8a 03 mov (%ebx),%al <== NOT EXECUTED 11fecc: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 11fece: 74 08 je 11fed8 <== NOT EXECUTED 11fed0: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 11fed2: 74 04 je 11fed8 <== NOT EXECUTED 11fed4: 84 c0 test %al,%al <== NOT EXECUTED 11fed6: 75 16 jne 11feee <== NOT EXECUTED 11fed8: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11fedb: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11fee0: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 11fee3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11fee8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 11feea: b1 01 mov $0x1,%cl <== NOT EXECUTED 11feec: eb 12 jmp 11ff00 <== NOT EXECUTED 11feee: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11fef1: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 11fef6: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 11fef9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 11fefe: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !parent_loc.ops->evalformake_h ) { 11ff00: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ff03: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 11ff06: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff08: 75 21 jne 11ff2b <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ff0a: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ff0d: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff0f: 0f 84 de 00 00 00 je 11fff3 <== NOT EXECUTED 11ff15: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff18: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff1a: 0f 84 d3 00 00 00 je 11fff3 <== NOT EXECUTED 11ff20: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff23: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11ff26: e9 c2 00 00 00 jmp 11ffed <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 11ff2b: 56 push %esi <== NOT EXECUTED 11ff2c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11ff2f: 50 push %eax <== NOT EXECUTED 11ff30: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 11ff33: 57 push %edi <== NOT EXECUTED 11ff34: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED 11ff37: 50 push %eax <== NOT EXECUTED 11ff38: ff d2 call *%edx <== NOT EXECUTED 11ff3a: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 11ff3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ff3f: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff41: 74 29 je 11ff6c <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ff43: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ff46: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff48: 74 13 je 11ff5d <== NOT EXECUTED 11ff4a: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff4d: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff4f: 74 0c je 11ff5d <== NOT EXECUTED 11ff51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff54: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11ff57: 50 push %eax <== NOT EXECUTED 11ff58: ff d2 call *%edx <== NOT EXECUTED 11ff5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 11ff5d: e8 ea b4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ff62: 89 30 mov %esi,(%eax) <== NOT EXECUTED 11ff64: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 11ff67: e9 d8 00 00 00 jmp 120044 <== 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 ) { 11ff6c: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11ff6f: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 11ff72: 74 41 je 11ffb5 <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ff74: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ff77: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff79: 74 13 je 11ff8e <== NOT EXECUTED 11ff7b: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff7e: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff80: 74 0c je 11ff8e <== NOT EXECUTED 11ff82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff85: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11ff88: 50 push %eax <== NOT EXECUTED 11ff89: ff d2 call *%edx <== NOT EXECUTED 11ff8b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 11ff8e: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ff91: 85 c0 test %eax,%eax <== NOT EXECUTED 11ff93: 74 13 je 11ffa8 <== NOT EXECUTED 11ff95: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ff98: 85 d2 test %edx,%edx <== NOT EXECUTED 11ff9a: 74 0c je 11ffa8 <== NOT EXECUTED 11ff9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ff9f: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 11ffa2: 50 push %eax <== NOT EXECUTED 11ffa3: ff d2 call *%edx <== NOT EXECUTED 11ffa5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 11ffa8: e8 9f b4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11ffad: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 11ffb3: eb af jmp 11ff64 <== NOT EXECUTED } if ( !parent_loc.ops->link_h ) { 11ffb5: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ffb8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 11ffbb: 85 c0 test %eax,%eax <== NOT EXECUTED 11ffbd: 75 44 jne 120003 <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 11ffbf: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11ffc2: 85 c0 test %eax,%eax <== NOT EXECUTED 11ffc4: 74 13 je 11ffd9 <== NOT EXECUTED 11ffc6: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ffc9: 85 d2 test %edx,%edx <== NOT EXECUTED 11ffcb: 74 0c je 11ffd9 <== NOT EXECUTED 11ffcd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ffd0: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11ffd3: 50 push %eax <== NOT EXECUTED 11ffd4: ff d2 call *%edx <== NOT EXECUTED 11ffd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 11ffd9: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 11ffdc: 85 c0 test %eax,%eax <== NOT EXECUTED 11ffde: 74 13 je 11fff3 <== NOT EXECUTED 11ffe0: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 11ffe3: 85 d2 test %edx,%edx <== NOT EXECUTED 11ffe5: 74 0c je 11fff3 <== NOT EXECUTED 11ffe7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11ffea: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 11ffed: 50 push %eax <== NOT EXECUTED 11ffee: ff d2 call *%edx <== NOT EXECUTED 11fff0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11fff3: e8 54 b4 00 00 call 12b44c <__errno> <== NOT EXECUTED 11fff8: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11fffe: e9 61 ff ff ff jmp 11ff64 <== NOT EXECUTED } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 120003: 52 push %edx <== NOT EXECUTED 120004: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 120007: 57 push %edi <== NOT EXECUTED 120008: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 12000b: 57 push %edi <== NOT EXECUTED 12000c: ff d0 call *%eax <== NOT EXECUTED 12000e: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 120010: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120016: 85 c0 test %eax,%eax <== NOT EXECUTED 120018: 74 10 je 12002a <== NOT EXECUTED 12001a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12001d: 85 c0 test %eax,%eax <== NOT EXECUTED 12001f: 74 09 je 12002a <== NOT EXECUTED 120021: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120024: 57 push %edi <== NOT EXECUTED 120025: ff d0 call *%eax <== NOT EXECUTED 120027: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 12002a: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 12002d: 85 c0 test %eax,%eax <== NOT EXECUTED 12002f: 74 13 je 120044 <== NOT EXECUTED 120031: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 120034: 85 d2 test %edx,%edx <== NOT EXECUTED 120036: 74 0c je 120044 <== NOT EXECUTED 120038: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12003b: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 12003e: 50 push %eax <== NOT EXECUTED 12003f: ff d2 call *%edx <== NOT EXECUTED 120041: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120044: 89 f0 mov %esi,%eax <== NOT EXECUTED 120046: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120049: 5b pop %ebx <== NOT EXECUTED 12004a: 5e pop %esi <== NOT EXECUTED 12004b: 5f pop %edi <== NOT EXECUTED 12004c: c9 leave <== NOT EXECUTED 12004d: c3 ret <== NOT EXECUTED 001091e8 : int mode, struct aiocb * const list[], int nent, struct sigevent *sig ) { 1091e8: 55 push %ebp <== NOT EXECUTED 1091e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091eb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1091ee: e8 e1 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1091f3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1091f9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1091fc: c9 leave <== NOT EXECUTED 1091fd: c3 ret <== NOT EXECUTED 001155a0 : off_t lseek( int fd, off_t offset, int whence ) { 1155a0: 55 push %ebp <== NOT EXECUTED 1155a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1155a3: 56 push %esi <== NOT EXECUTED 1155a4: 53 push %ebx <== NOT EXECUTED 1155a5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1155a8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1155ab: 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 ); 1155ae: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 1155b4: 73 0f jae 1155c5 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1155b6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 1155b9: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1155bf: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 1155c3: 75 0d jne 1155d2 <== NOT EXECUTED 1155c5: e8 ee 9a ff ff call 10f0b8 <__errno> <== NOT EXECUTED 1155ca: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1155d0: eb 46 jmp 115618 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 1155d2: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 1155d5: 83 78 14 00 cmpl $0x0,0x14(%eax) <== NOT EXECUTED 1155d9: 75 0d jne 1155e8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1155db: e8 d8 9a ff ff call 10f0b8 <__errno> <== NOT EXECUTED 1155e0: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1155e6: eb 30 jmp 115618 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 1155e8: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED switch ( whence ) { 1155eb: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1155ee: 74 0e je 1155fe <== NOT EXECUTED 1155f0: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 1155f3: 74 0e je 115603 <== NOT EXECUTED 1155f5: 85 d2 test %edx,%edx <== NOT EXECUTED 1155f7: 75 14 jne 11560d <== NOT EXECUTED case SEEK_SET: iop->offset = offset; 1155f9: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 1155fc: eb 1f jmp 11561d <== NOT EXECUTED break; case SEEK_CUR: iop->offset += offset; 1155fe: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 115601: eb 05 jmp 115608 <== NOT EXECUTED break; case SEEK_END: iop->offset = iop->size + offset; 115603: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115605: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 115608: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 11560b: eb 10 jmp 11561d <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 11560d: e8 a6 9a ff ff call 10f0b8 <__errno> <== NOT EXECUTED 115612: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 115618: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11561b: eb 15 jmp 115632 <== NOT EXECUTED /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 11561d: 50 push %eax <== NOT EXECUTED 11561e: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 115621: 52 push %edx <== NOT EXECUTED 115622: 51 push %ecx <== NOT EXECUTED 115623: 53 push %ebx <== NOT EXECUTED 115624: ff 50 14 call *0x14(%eax) <== NOT EXECUTED if ( status == (off_t) -1 ) 115627: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11562a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 11562d: 75 03 jne 115632 <== NOT EXECUTED iop->offset = old_offset; 11562f: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 115632: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 115635: 5b pop %ebx <== NOT EXECUTED 115636: 5e pop %esi <== NOT EXECUTED 115637: c9 leave <== NOT EXECUTED 115638: c3 ret <== NOT EXECUTED 00120118 : int _STAT_NAME( const char *path, struct stat *buf ) { 120118: 55 push %ebp <== NOT EXECUTED 120119: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12011b: 57 push %edi <== NOT EXECUTED 12011c: 56 push %esi <== NOT EXECUTED 12011d: 53 push %ebx <== NOT EXECUTED 12011e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 120121: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 120125: 75 0d jne 120134 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 120127: e8 20 b3 00 00 call 12b44c <__errno> <== NOT EXECUTED 12012c: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 120132: eb 45 jmp 120179 <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 120134: 6a 00 push $0x0 <== NOT EXECUTED 120136: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 120139: 56 push %esi <== NOT EXECUTED 12013a: 6a 00 push $0x0 <== NOT EXECUTED 12013c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12013f: e8 b6 9d fe ff call 109efa <== NOT EXECUTED if ( status != 0 ) 120144: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120147: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 12014a: 85 c0 test %eax,%eax <== NOT EXECUTED 12014c: 75 5f jne 1201ad <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 12014e: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 120151: 83 7a 18 00 cmpl $0x0,0x18(%edx) <== NOT EXECUTED 120155: 75 27 jne 12017e <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120157: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12015a: 85 c0 test %eax,%eax <== NOT EXECUTED 12015c: 74 10 je 12016e <== NOT EXECUTED 12015e: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120161: 85 c0 test %eax,%eax <== NOT EXECUTED 120163: 74 09 je 12016e <== NOT EXECUTED 120165: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120168: 56 push %esi <== NOT EXECUTED 120169: ff d0 call *%eax <== NOT EXECUTED 12016b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12016e: e8 d9 b2 00 00 call 12b44c <__errno> <== NOT EXECUTED 120173: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120179: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 12017c: eb 2f jmp 1201ad <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 12017e: b9 13 00 00 00 mov $0x13,%ecx <== NOT EXECUTED 120183: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 120186: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 120188: 50 push %eax <== NOT EXECUTED 120189: 50 push %eax <== NOT EXECUTED 12018a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12018d: 56 push %esi <== NOT EXECUTED 12018e: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 120191: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120193: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120196: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120199: 85 c0 test %eax,%eax <== NOT EXECUTED 12019b: 74 10 je 1201ad <== NOT EXECUTED 12019d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1201a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1201a2: 74 09 je 1201ad <== NOT EXECUTED 1201a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1201a7: 56 push %esi <== NOT EXECUTED 1201a8: ff d0 call *%eax <== NOT EXECUTED 1201aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 1201ad: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1201af: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1201b2: 5b pop %ebx <== NOT EXECUTED 1201b3: 5e pop %esi <== NOT EXECUTED 1201b4: 5f pop %edi <== NOT EXECUTED 1201b5: c9 leave <== NOT EXECUTED 1201b6: 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 8c d5 11 00 incl 0x11d58c <== 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 18 d8 11 00 03 cmpl $0x3,0x11d818 <== 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 30 d5 11 00 push $0x11d530 <== NOT EXECUTED 106695: e8 72 42 00 00 call 10a90c <_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 b8 ba 11 00 mov 0x11bab8,%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 f9 89 00 00 call 10f0b8 <__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 bc ba 11 00 mov 0x11babc,%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 b4 ba 11 00 mov 0x11bab4,%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 24 d5 11 00 push $0x11d524 <== NOT EXECUTED 1065b5: e8 06 35 00 00 call 109ac0 <_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 24 d5 11 00 28 movl $0x11d528,0x11d524 <== NOT EXECUTED 10658e: d5 11 00 <== NOT EXECUTED 106591: c7 05 28 d5 11 00 00 movl $0x0,0x11d528 <== NOT EXECUTED 106598: 00 00 00 <== NOT EXECUTED 10659b: c7 05 2c d5 11 00 24 movl $0x11d524,0x11d52c <== NOT EXECUTED 1065a2: d5 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 24 d5 11 00 push $0x11d524 <== NOT EXECUTED 1065db: e8 04 35 00 00 call 109ae4 <_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 78 ab 15 00 push $0x15ab78 <== NOT EXECUTED 10a457: e8 20 50 00 00 call 10f47c <_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 001201cc : */ int malloc_info( Heap_Information_block *the_info ) { 1201cc: 55 push %ebp <== NOT EXECUTED 1201cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1201cf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1201d2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_info ) 1201d5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1201d8: 85 d2 test %edx,%edx <== NOT EXECUTED 1201da: 74 12 je 1201ee <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); 1201dc: 50 push %eax <== NOT EXECUTED 1201dd: 50 push %eax <== NOT EXECUTED 1201de: 52 push %edx <== NOT EXECUTED 1201df: 68 78 ab 15 00 push $0x15ab78 <== NOT EXECUTED 1201e4: e8 cb 22 00 00 call 1224b4 <_Protected_heap_Get_information> <== NOT EXECUTED 1201e9: 31 c0 xor %eax,%eax <== NOT EXECUTED 1201eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1201ee: c9 leave <== NOT EXECUTED 1201ef: 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 78 d6 11 00 mov 0x11d678,%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 14 d7 11 00 mov 0x11d714,%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 001201f0 : void malloc_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 1201f0: 55 push %ebp <== NOT EXECUTED 1201f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1201f3: 57 push %edi <== NOT EXECUTED 1201f4: 56 push %esi <== NOT EXECUTED 1201f5: 53 push %ebx <== NOT EXECUTED 1201f6: 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; 1201f9: 8b 0d ec ab 15 00 mov 0x15abec,%ecx <== NOT EXECUTED 1201ff: 8b 1d f0 ab 15 00 mov 0x15abf0,%ebx <== NOT EXECUTED 120205: a1 f4 ab 15 00 mov 0x15abf4,%eax <== NOT EXECUTED 12020a: 8b 15 f8 ab 15 00 mov 0x15abf8,%edx <== NOT EXECUTED 120210: 89 ce mov %ecx,%esi <== NOT EXECUTED 120212: 29 c6 sub %eax,%esi <== NOT EXECUTED 120214: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (*print)( 120217: 8b 3d e8 ab 15 00 mov 0x15abe8,%edi <== NOT EXECUTED 12021d: 8b 35 d0 ab 15 00 mov 0x15abd0,%esi <== NOT EXECUTED 120223: 0f ac d0 0a shrd $0xa,%edx,%eax <== NOT EXECUTED 120227: c1 ea 0a shr $0xa,%edx <== NOT EXECUTED 12022a: 50 push %eax <== NOT EXECUTED 12022b: 0f ac d9 0a shrd $0xa,%ebx,%ecx <== NOT EXECUTED 12022f: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 120232: 51 push %ecx <== NOT EXECUTED 120233: 6b c7 64 imul $0x64,%edi,%eax <== NOT EXECUTED 120236: 31 d2 xor %edx,%edx <== NOT EXECUTED 120238: f7 f6 div %esi <== NOT EXECUTED 12023a: 50 push %eax <== NOT EXECUTED 12023b: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 12023e: 57 push %edi <== NOT EXECUTED 12023f: 6b 45 f0 64 imul $0x64,-0x10(%ebp),%eax <== NOT EXECUTED 120243: 31 d2 xor %edx,%edx <== NOT EXECUTED 120245: f7 f6 div %esi <== NOT EXECUTED 120247: 50 push %eax <== NOT EXECUTED 120248: c1 6d f0 0a shrl $0xa,-0x10(%ebp) <== NOT EXECUTED 12024c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 12024f: c1 ee 0a shr $0xa,%esi <== NOT EXECUTED 120252: 56 push %esi <== NOT EXECUTED 120253: 68 3e dd 13 00 push $0x13dd3e <== NOT EXECUTED 120258: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12025b: 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)( 12025e: 83 c4 28 add $0x28,%esp <== NOT EXECUTED 120261: ff 35 e4 ab 15 00 pushl 0x15abe4 <== NOT EXECUTED 120267: ff 35 e0 ab 15 00 pushl 0x15abe0 <== NOT EXECUTED 12026d: ff 35 dc ab 15 00 pushl 0x15abdc <== NOT EXECUTED 120273: ff 35 d4 ab 15 00 pushl 0x15abd4 <== NOT EXECUTED 120279: 68 a0 dd 13 00 push $0x13dda0 <== NOT EXECUTED 12027e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120281: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 120284: 83 c4 20 add $0x20,%esp <== NOT EXECUTED s->malloc_calls, s->free_calls, s->realloc_calls, s->calloc_calls ); } 120287: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12028a: 5b pop %ebx <== NOT EXECUTED 12028b: 5e pop %esi <== NOT EXECUTED 12028c: 5f pop %edi <== NOT EXECUTED 12028d: c9 leave <== NOT EXECUTED 12028e: 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 5c 18 12 00 push $0x12185c <== NOT EXECUTED 107aa8: e8 43 4d 00 00 call 10c7f0 <_Protected_heap_Walk> <== NOT EXECUTED 107aad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107ab0: c9 leave <== NOT EXECUTED 107ab1: c3 ret <== NOT EXECUTED 00124478 : */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) { 124478: 55 push %ebp <== NOT EXECUTED 124479: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12447b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK); 12447e: ff 35 70 7a 14 00 pushl 0x147a70 <== NOT EXECUTED 124484: 6a 01 push $0x1 <== NOT EXECUTED 124486: e8 91 58 fe ff call 109d1c <== NOT EXECUTED if ( memory ) 12448b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12448e: 85 c0 test %eax,%eax <== NOT EXECUTED 124490: 74 06 je 124498 <== NOT EXECUTED memfile_blocks_allocated++; 124492: ff 05 88 a3 15 00 incl 0x15a388 <== NOT EXECUTED return memory; } 124498: c9 leave <== NOT EXECUTED 124499: c3 ret <== NOT EXECUTED 00124802 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 124802: 55 push %ebp <== NOT EXECUTED 124803: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124805: 53 push %ebx <== NOT EXECUTED 124806: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 124809: 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) ) { 12480c: 53 push %ebx <== NOT EXECUTED 12480d: e8 de 59 fe ff call 10a1f0 <== NOT EXECUTED 124812: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124815: 85 c0 test %eax,%eax <== NOT EXECUTED 124817: 75 36 jne 12484f <== NOT EXECUTED 124819: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 12481e: 75 2f jne 12484f <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 124820: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 124825: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 124828: 75 07 jne 124831 <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; 12482a: 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) 124831: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 124835: 74 0c je 124843 <== NOT EXECUTED IMFS_memfile_remove( the_jnode ); 124837: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12483a: 53 push %ebx <== NOT EXECUTED 12483b: e8 7b fe ff ff call 1246bb <== NOT EXECUTED 124840: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( the_jnode ); 124843: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124846: 53 push %ebx <== NOT EXECUTED 124847: e8 d0 57 fe ff call 10a01c <== NOT EXECUTED 12484c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 12484f: 31 c0 xor %eax,%eax <== NOT EXECUTED 124851: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124854: c9 leave <== NOT EXECUTED 124855: c3 ret <== NOT EXECUTED 0012489f : */ int memfile_close( rtems_libio_t *iop ) { 12489f: 55 push %ebp <== NOT EXECUTED 1248a0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1248a2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1248a5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1248a8: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED if (iop->flags & LIBIO_FLAGS_APPEND) 1248ab: f6 42 0d 02 testb $0x2,0xd(%edx) <== NOT EXECUTED 1248af: 74 06 je 1248b7 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 1248b1: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 1248b4: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED memfile_check_rmnod( the_jnode ); 1248b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1248ba: 51 push %ecx <== NOT EXECUTED 1248bb: e8 42 ff ff ff call 124802 <== NOT EXECUTED return 0; } 1248c0: 31 c0 xor %eax,%eax <== NOT EXECUTED 1248c2: c9 leave <== NOT EXECUTED 1248c3: c3 ret <== NOT EXECUTED 0012445f : */ void memfile_free_block( void *memory ) { 12445f: 55 push %ebp <== NOT EXECUTED 124460: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124462: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #if 0 fprintf(stdout, "(d %p) ", memory ); fflush(stdout); #endif free(memory); 124465: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124468: e8 af 5b fe ff call 10a01c <== NOT EXECUTED memfile_blocks_allocated--; 12446d: ff 0d 88 a3 15 00 decl 0x15a388 <== NOT EXECUTED 124473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 124476: c9 leave <== NOT EXECUTED 124477: c3 ret <== NOT EXECUTED 00124651 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 124651: 55 push %ebp <== NOT EXECUTED 124652: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124654: 57 push %edi <== NOT EXECUTED 124655: 56 push %esi <== NOT EXECUTED 124656: 53 push %ebx <== NOT EXECUTED 124657: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12465a: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 12465d: 85 f6 test %esi,%esi <== NOT EXECUTED 12465f: 75 19 jne 12467a <== NOT EXECUTED 124661: 68 7c e1 13 00 push $0x13e17c <== NOT EXECUTED 124666: 68 68 e2 13 00 push $0x13e268 <== NOT EXECUTED 12466b: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED 124670: 68 0f e1 13 00 push $0x13e10f <== NOT EXECUTED 124675: e8 4a 56 fe ff call 109cc4 <__assert_func> <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 12467a: 8b 3e mov (%esi),%edi <== NOT EXECUTED 12467c: 31 db xor %ebx,%ebx <== NOT EXECUTED 12467e: eb 1b jmp 12469b <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED memfile_free_block( b[i] ); 124687: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12468a: 50 push %eax <== NOT EXECUTED 12468b: e8 cf fd ff ff call 12445f <== NOT EXECUTED b[i] = 0; 124690: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4) <== NOT EXECUTED 124697: 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 ); 1246a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1246a3: ff 36 pushl (%esi) <== NOT EXECUTED 1246a5: e8 b5 fd ff ff call 12445f <== NOT EXECUTED *block_table = 0; 1246aa: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 1246b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1246b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1246b6: 5b pop %ebx <== NOT EXECUTED 1246b7: 5e pop %esi <== NOT EXECUTED 1246b8: 5f pop %edi <== NOT EXECUTED 1246b9: c9 leave <== NOT EXECUTED 1246ba: c3 ret <== NOT EXECUTED 00124a06 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 124a06: 55 push %ebp <== NOT EXECUTED 124a07: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124a09: 53 push %ebx <== NOT EXECUTED 124a0a: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 124a0d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 124a10: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124a13: 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 ) 124a16: 3b 43 50 cmp 0x50(%ebx),%eax <== NOT EXECUTED 124a19: 7e 0b jle 124a26 <== NOT EXECUTED return IMFS_memfile_extend( the_jnode, length ); 124a1b: 52 push %edx <== NOT EXECUTED 124a1c: 52 push %edx <== NOT EXECUTED 124a1d: 50 push %eax <== NOT EXECUTED 124a1e: 53 push %ebx <== NOT EXECUTED 124a1f: e8 0f ff ff ff call 124933 <== NOT EXECUTED 124a24: eb 1b jmp 124a41 <== 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; 124a26: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124a29: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 124a2c: 50 push %eax <== NOT EXECUTED 124a2d: 50 push %eax <== NOT EXECUTED 124a2e: 6a 00 push $0x0 <== NOT EXECUTED 124a30: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 124a33: 50 push %eax <== NOT EXECUTED 124a34: e8 5b 56 fe ff call 10a094 <== NOT EXECUTED 124a39: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 124a3c: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED 124a3f: 31 c0 xor %eax,%eax <== NOT EXECUTED 124a41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 124a44: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124a47: c9 leave <== NOT EXECUTED 124a48: c3 ret <== NOT EXECUTED 00124458 : int memfile_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 124458: 55 push %ebp <== NOT EXECUTED 124459: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return 0; } 12445b: 31 c0 xor %eax,%eax <== NOT EXECUTED 12445d: c9 leave <== NOT EXECUTED 12445e: c3 ret <== NOT EXECUTED 00124a49 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 124a49: 55 push %ebp <== NOT EXECUTED 124a4a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124a4c: 56 push %esi <== NOT EXECUTED 124a4d: 53 push %ebx <== NOT EXECUTED 124a4e: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124a51: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED if (the_jnode->type == IMFS_LINEAR_FILE) { 124a54: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 124a58: 75 0d jne 124a67 <== NOT EXECUTED if (iop->offset > the_jnode->info.linearfile.size) 124a5a: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124a5d: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED 124a60: 7e 2d jle 124a8f <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 124a62: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 124a65: eb 28 jmp 124a8f <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 124a67: 51 push %ecx <== NOT EXECUTED 124a68: 51 push %ecx <== NOT EXECUTED 124a69: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 124a6c: 53 push %ebx <== NOT EXECUTED 124a6d: e8 c1 fe ff ff call 124933 <== NOT EXECUTED 124a72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124a75: 85 c0 test %eax,%eax <== NOT EXECUTED 124a77: 74 10 je 124a89 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 124a79: e8 ce 69 00 00 call 12b44c <__errno> <== NOT EXECUTED 124a7e: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 124a84: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 124a87: eb 09 jmp 124a92 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124a89: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124a8c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED } return iop->offset; 124a8f: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED } 124a92: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124a95: 5b pop %ebx <== NOT EXECUTED 124a96: 5e pop %esi <== NOT EXECUTED 124a97: c9 leave <== NOT EXECUTED 124a98: c3 ret <== NOT EXECUTED 00124c90 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 124c90: 55 push %ebp <== NOT EXECUTED 124c91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124c93: 56 push %esi <== NOT EXECUTED 124c94: 53 push %ebx <== NOT EXECUTED 124c95: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 124c98: 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)) 124c9b: f7 46 0c 04 02 00 00 testl $0x204,0xc(%esi) <== NOT EXECUTED 124ca2: 74 46 je 124cea <== NOT EXECUTED 124ca4: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 124ca8: 75 40 jne 124cea <== NOT EXECUTED && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 124caa: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 124cad: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 124cb0: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 124cb7: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 124cbe: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 124cc5: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 124ccc: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED if ((count != 0) 124cd3: 85 c0 test %eax,%eax <== NOT EXECUTED 124cd5: 74 13 je 124cea <== NOT EXECUTED 124cd7: 50 push %eax <== NOT EXECUTED 124cd8: 52 push %edx <== NOT EXECUTED 124cd9: 6a 00 push $0x0 <== NOT EXECUTED 124cdb: 53 push %ebx <== NOT EXECUTED 124cdc: e8 b8 fd ff ff call 124a99 <== NOT EXECUTED 124ce1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124ce4: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 124ce7: 40 inc %eax <== NOT EXECUTED 124ce8: 74 14 je 124cfe <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 124cea: f6 46 0d 02 testb $0x2,0xd(%esi) <== NOT EXECUTED 124cee: 74 06 je 124cf6 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 124cf0: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124cf3: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124cf6: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 124cf9: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 124cfc: 31 d2 xor %edx,%edx <== NOT EXECUTED return 0; } 124cfe: 89 d0 mov %edx,%eax <== NOT EXECUTED 124d00: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124d03: 5b pop %ebx <== NOT EXECUTED 124d04: 5e pop %esi <== NOT EXECUTED 124d05: c9 leave <== NOT EXECUTED 124d06: c3 ret <== NOT EXECUTED 00124f0f : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 124f0f: 55 push %ebp <== NOT EXECUTED 124f10: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124f12: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124f15: 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 ); 124f18: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 124f1b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124f1e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 124f21: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 124f24: e8 de fd ff ff call 124d07 <== NOT EXECUTED } 124f29: c9 leave <== NOT EXECUTED 124f2a: c3 ret <== NOT EXECUTED 00124856 : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 124856: 55 push %ebp <== NOT EXECUTED 124857: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124859: 53 push %ebx <== NOT EXECUTED 12485a: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 12485d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124860: 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 ) { 124862: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 124866: 74 13 je 12487b <== NOT EXECUTED 124868: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12486b: 53 push %ebx <== NOT EXECUTED 12486c: e8 87 99 fe ff call 10e1f8 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 124871: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 124878: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 12487b: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 12487f: 50 push %eax <== NOT EXECUTED 124880: 50 push %eax <== NOT EXECUTED 124881: 6a 00 push $0x0 <== NOT EXECUTED 124883: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 124886: 50 push %eax <== NOT EXECUTED 124887: e8 08 58 fe ff call 10a094 <== NOT EXECUTED 12488c: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12488f: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return memfile_check_rmnod( the_jnode ); 124892: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 124895: e8 68 ff ff ff call 124802 <== NOT EXECUTED } 12489a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 12489d: c9 leave <== NOT EXECUTED 12489e: c3 ret <== NOT EXECUTED 00124c69 : ssize_t memfile_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 124c69: 55 push %ebp <== NOT EXECUTED 124c6a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124c6c: 56 push %esi <== NOT EXECUTED 124c6d: 53 push %ebx <== NOT EXECUTED 124c6e: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; ssize_t status; the_jnode = iop->file_info; 124c71: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count ); 124c74: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 124c77: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124c7a: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 124c7d: 56 push %esi <== NOT EXECUTED 124c7e: e8 16 fe ff ff call 124a99 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 124c83: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 124c86: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED return status; } 124c89: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124c8c: 5b pop %ebx <== NOT EXECUTED 124c8d: 5e pop %esi <== NOT EXECUTED 124c8e: c9 leave <== NOT EXECUTED 124c8f: c3 ret <== NOT EXECUTED 0010c1e8 : */ int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10c1e8: 55 push %ebp <== NOT EXECUTED 10c1e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1eb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 10c1ee: 68 38 d4 11 00 push $0x11d438 <== NOT EXECUTED 10c1f3: 68 38 d4 11 00 push $0x11d438 <== NOT EXECUTED 10c1f8: 68 d0 74 11 00 push $0x1174d0 <== NOT EXECUTED 10c1fd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c200: e8 d3 06 00 00 call 10c8d8 <== NOT EXECUTED temp_mt_entry, &miniIMFS_ops, &rtems_filesystem_null_handlers, /* for memfiles */ &rtems_filesystem_null_handlers /* for directories */ ); } 10c205: c9 leave <== NOT EXECUTED 10c206: c3 ret <== NOT EXECUTED 0010d068 : int mkdir( const char *pathname, mode_t mode ) { 10d068: 55 push %ebp <== NOT EXECUTED 10d069: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d06b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d06e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( pathname, mode | S_IFDIR, 0LL); 10d071: 6a 00 push $0x0 <== NOT EXECUTED 10d073: 6a 00 push $0x0 <== NOT EXECUTED 10d075: 80 cc 40 or $0x40,%ah <== NOT EXECUTED 10d078: 50 push %eax <== NOT EXECUTED 10d079: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d07c: e8 7b 96 ff ff call 1066fc <== NOT EXECUTED } 10d081: c9 leave <== NOT EXECUTED 10d082: c3 ret <== NOT EXECUTED 00120290 : int mkfifo( const char *path, mode_t mode ) { 120290: 55 push %ebp <== NOT EXECUTED 120291: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120293: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 120296: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( path, mode | S_IFIFO, 0LL ); 120299: 6a 00 push $0x0 <== NOT EXECUTED 12029b: 6a 00 push $0x0 <== NOT EXECUTED 12029d: 80 cc 10 or $0x10,%ah <== NOT EXECUTED 1202a0: 50 push %eax <== NOT EXECUTED 1202a1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1202a4: e8 8b a3 fe ff call 10a634 <== NOT EXECUTED } 1202a9: c9 leave <== NOT EXECUTED 1202aa: 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 96 89 00 00 call 10f0b8 <__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 82 89 00 00 call 10f0b8 <__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 4c b5 11 00 mov 0x11b54c,%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 4c b5 11 00 mov 0x11b54c,%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 0010d0a9 : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10d0a9: 55 push %ebp <== NOT EXECUTED 10d0aa: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0ac: 57 push %edi <== NOT EXECUTED 10d0ad: 56 push %esi <== NOT EXECUTED 10d0ae: 53 push %ebx <== NOT EXECUTED 10d0af: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10d0b2: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10d0b5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10d0b9: 74 05 je 10d0c0 <== NOT EXECUTED /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10d0bb: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10d0be: 76 10 jbe 10d0d0 <== NOT EXECUTED options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 10d0c0: e8 f3 1f 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d0c5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d0cb: e9 e4 01 00 00 jmp 10d2b4 <== NOT EXECUTED return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10d0d0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d0d3: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 10d0d7: 75 17 jne 10d0f0 <== NOT EXECUTED errno = ENOTSUP; 10d0d9: e8 da 1f 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d0de: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d0e4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10d0eb: e9 94 01 00 00 jmp 10d284 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10d0f0: b8 64 00 00 00 mov $0x64,%eax <== NOT EXECUTED 10d0f5: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10d0f9: 74 0f je 10d10a <== NOT EXECUTED size += strlen( device ) + 1; 10d0fb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d0fd: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 10d100: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10d103: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10d105: f7 d1 not %ecx <== NOT EXECUTED 10d107: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10d10a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d10d: 50 push %eax <== NOT EXECUTED 10d10e: e8 51 95 ff ff call 106664 <== NOT EXECUTED 10d113: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d115: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !temp_mt_entry ) { 10d118: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d11b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d11d: 75 10 jne 10d12f <== NOT EXECUTED errno = ENOMEM; 10d11f: e8 94 1f 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d124: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10d12a: e9 85 01 00 00 jmp 10d2b4 <== NOT EXECUTED return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10d12f: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED temp_mt_entry->options = options; 10d132: 89 70 28 mov %esi,0x28(%eax) <== NOT EXECUTED if ( device ) { 10d135: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10d139: 74 16 je 10d151 <== NOT EXECUTED temp_mt_entry->dev = 10d13b: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10d13e: 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 ); 10d141: 52 push %edx <== NOT EXECUTED 10d142: 52 push %edx <== NOT EXECUTED 10d143: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10d146: 50 push %eax <== NOT EXECUTED 10d147: e8 cc 30 00 00 call 110218 <== NOT EXECUTED 10d14c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d14f: eb 07 jmp 10d158 <== NOT EXECUTED } else temp_mt_entry->dev = 0; 10d151: 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 ) { 10d158: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 10d15c: 0f 84 a8 00 00 00 je 10d20a <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( 10d162: 6a 01 push $0x1 <== NOT EXECUTED 10d164: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10d167: 56 push %esi <== NOT EXECUTED 10d168: 6a 07 push $0x7 <== NOT EXECUTED 10d16a: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10d16d: e8 d4 91 ff ff call 106346 <== NOT EXECUTED 10d172: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d175: 40 inc %eax <== NOT EXECUTED 10d176: 0f 84 08 01 00 00 je 10d284 <== NOT EXECUTED /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10d17c: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d17f: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d182: 85 c0 test %eax,%eax <== NOT EXECUTED 10d184: 75 10 jne 10d196 <== NOT EXECUTED errno = ENOTSUP; 10d186: e8 2d 1f 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d18b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d191: e9 f0 00 00 00 jmp 10d286 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10d196: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d199: 56 push %esi <== NOT EXECUTED 10d19a: ff d0 call *%eax <== NOT EXECUTED 10d19c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d19f: 48 dec %eax <== NOT EXECUTED 10d1a0: 74 10 je 10d1b2 <== NOT EXECUTED errno = ENOTDIR; 10d1a2: e8 11 1f 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d1a7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10d1ad: e9 d4 00 00 00 jmp 10d286 <== NOT EXECUTED /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10d1b2: a1 10 dc 11 00 mov 0x11dc10,%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 ) 10d1b7: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10d1ba: eb 07 jmp 10d1c3 <== NOT EXECUTED 10d1bc: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10d1bf: 74 0e je 10d1cf <== 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 ) { 10d1c1: 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 ); 10d1c3: 3d 14 dc 11 00 cmp $0x11dc14,%eax <== NOT EXECUTED 10d1c8: 75 f2 jne 10d1bc <== NOT EXECUTED 10d1ca: e9 f0 00 00 00 jmp 10d2bf <== NOT EXECUTED /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10d1cf: e8 e4 1e 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d1d4: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10d1da: eb 0b jmp 10d1e7 <== 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; 10d1dc: e8 d7 1e 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d1e1: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d1e7: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10d1ea: e9 97 00 00 00 jmp 10d286 <== NOT EXECUTED goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10d1ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1f2: 53 push %ebx <== NOT EXECUTED 10d1f3: ff d0 call *%eax <== NOT EXECUTED 10d1f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1fa: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10d1fd: 74 07 je 10d206 <== NOT EXECUTED 10d1ff: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d201: e9 80 00 00 00 jmp 10d286 <== NOT EXECUTED 10d206: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d208: eb 33 jmp 10d23d <== 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; 10d20a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.handlers = NULL; 10d211: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = NULL; 10d218: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.node_access = NULL; 10d21f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = NULL; 10d226: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = NULL; 10d22d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = NULL; 10d234: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED 10d23b: 31 f6 xor %esi,%esi <== NOT EXECUTED } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10d23d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d240: 53 push %ebx <== NOT EXECUTED 10d241: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d244: ff 52 24 call *0x24(%edx) <== NOT EXECUTED 10d247: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d24a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d24c: 74 15 je 10d263 <== NOT EXECUTED /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10d24e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d251: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10d254: 85 c0 test %eax,%eax <== NOT EXECUTED 10d256: 74 2e je 10d286 <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10d258: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d25b: 53 push %ebx <== NOT EXECUTED 10d25c: ff d0 call *%eax <== NOT EXECUTED 10d25e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d261: eb 23 jmp 10d286 <== NOT EXECUTED 10d263: 50 push %eax <== NOT EXECUTED 10d264: 50 push %eax <== NOT EXECUTED 10d265: 53 push %ebx <== NOT EXECUTED 10d266: 68 10 dc 11 00 push $0x11dc10 <== NOT EXECUTED 10d26b: e8 50 c8 ff ff call 109ac0 <_Chain_Append> <== NOT EXECUTED */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10d270: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d273: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d275: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10d279: 74 3c je 10d2b7 <== NOT EXECUTED *mt_entry = temp_mt_entry; 10d27b: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d27e: 89 1f mov %ebx,(%edi) <== NOT EXECUTED 10d280: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d282: eb 33 jmp 10d2b7 <== NOT EXECUTED 10d284: 31 f6 xor %esi,%esi <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10d286: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d289: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10d28c: e8 d7 91 ff ff call 106468 <== NOT EXECUTED if ( loc_to_free ) 10d291: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d294: 85 f6 test %esi,%esi <== NOT EXECUTED 10d296: 74 1c je 10d2b4 <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 10d298: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d29b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d29d: 74 15 je 10d2b4 <== NOT EXECUTED 10d29f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10d2a2: 85 c0 test %eax,%eax <== NOT EXECUTED 10d2a4: 74 0e je 10d2b4 <== NOT EXECUTED 10d2a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d2a9: 56 push %esi <== NOT EXECUTED 10d2aa: ff d0 call *%eax <== NOT EXECUTED 10d2ac: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d2af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d2b2: eb 03 jmp 10d2b7 <== NOT EXECUTED 10d2b4: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; } 10d2b7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d2ba: 5b pop %ebx <== NOT EXECUTED 10d2bb: 5e pop %esi <== NOT EXECUTED 10d2bc: 5f pop %edi <== NOT EXECUTED 10d2bd: c9 leave <== NOT EXECUTED 10d2be: 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; 10d2bf: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = loc.handlers; 10d2c2: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10d2c5: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = loc.ops; 10d2c8: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10d2cb: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10d2ce: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d2d1: 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 ){ 10d2d4: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10d2d7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d2d9: 0f 85 10 ff ff ff jne 10d1ef <== NOT EXECUTED 10d2df: e9 f8 fe ff ff jmp 10d1dc <== NOT EXECUTED 00109200 : * As of gcc 4.2.2, the gcc SPARC backend doesn't appear to have a * way to call this for RTEMS anymore but it doesn't hurt to leave it. */ int mprotect(const void *addr, size_t len, int prot) { 109200: 55 push %ebp <== NOT EXECUTED 109201: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 109203: 31 c0 xor %eax,%eax <== NOT EXECUTED 109205: c9 leave <== NOT EXECUTED 109206: c3 ret <== NOT EXECUTED 0010c464 : */ int mq_close( mqd_t mqdes ) { 10c464: 55 push %ebp <== NOT EXECUTED 10c465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c467: 53 push %ebx <== NOT EXECUTED 10c468: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10c46b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c46e: 50 push %eax <== NOT EXECUTED 10c46f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c472: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c477: e8 80 30 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED 10c47c: 89 c3 mov %eax,%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); if ( location == OBJECTS_LOCAL ) { 10c47e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c481: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10c485: 75 35 jne 10c4bc <== NOT EXECUTED * First update the actual message queue to reflect this descriptor * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; 10c487: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED the_mq->open_count -= 1; 10c48a: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Message_queue_Delete( the_mq ); 10c48d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c490: 50 push %eax <== NOT EXECUTED 10c491: e8 3a 00 00 00 call 10c4d0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED /* * Now close this file descriptor. */ _Objects_Close( 10c496: 59 pop %ecx <== NOT EXECUTED 10c497: 58 pop %eax <== NOT EXECUTED 10c498: 53 push %ebx <== NOT EXECUTED 10c499: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c49e: e8 89 2c 00 00 call 10f12c <_Objects_Close> <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10c4a3: 58 pop %eax <== NOT EXECUTED 10c4a4: 5a pop %edx <== NOT EXECUTED 10c4a5: 53 push %ebx <== NOT EXECUTED 10c4a6: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c4ab: e8 18 2f 00 00 call 10f3c8 <_Objects_Free> <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10c4b0: e8 53 38 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c4b5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c4b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4ba: eb 0e jmp 10c4ca <== NOT EXECUTED /* * OBJECTS_REMOTE: * OBJECTS_ERROR: */ rtems_set_errno_and_return_minus_one( EBADF ); 10c4bc: e8 ef 7e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c4c1: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10c4c7: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10c4ca: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c4cd: c9 leave <== NOT EXECUTED 10c4ce: c3 ret <== NOT EXECUTED 0010c52c : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10c52c: 55 push %ebp <== NOT EXECUTED 10c52d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c52f: 53 push %ebx <== NOT EXECUTED 10c530: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c533: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 10c536: 85 db test %ebx,%ebx <== NOT EXECUTED 10c538: 75 0d jne 10c547 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c53a: e8 71 7e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c53f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c545: eb 49 jmp 10c590 <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10c547: 50 push %eax <== NOT EXECUTED 10c548: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c54b: 50 push %eax <== NOT EXECUTED 10c54c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c54f: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c554: e8 a3 2f 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c559: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c55c: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10c560: 75 23 jne 10c585 <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10c562: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10c565: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10c568: 89 03 mov %eax,(%ebx) <== NOT EXECUTED mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10c56a: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10c56d: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10c570: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10c573: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10c576: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10c579: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10c57c: e8 87 37 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c581: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c583: eb 0e jmp 10c593 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c585: e8 26 7e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c58a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10c590: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10c593: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c596: c9 leave <== NOT EXECUTED 10c597: c3 ret <== NOT EXECUTED 0010c598 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 10c598: 55 push %ebp <== NOT EXECUTED 10c599: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c59b: 57 push %edi <== NOT EXECUTED 10c59c: 56 push %esi <== NOT EXECUTED 10c59d: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c5a0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c5a3: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10c5a6: 50 push %eax <== NOT EXECUTED 10c5a7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c5aa: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c5af: e8 48 2f 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c5b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5b7: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10c5bb: 75 5f jne 10c61c <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10c5bd: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED if ( notification ) { 10c5c0: 85 f6 test %esi,%esi <== NOT EXECUTED 10c5c2: 74 3e je 10c602 <== NOT EXECUTED if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 10c5c4: 83 78 7c 00 cmpl $0x0,0x7c(%eax) <== NOT EXECUTED 10c5c8: 74 12 je 10c5dc <== NOT EXECUTED _Thread_Enable_dispatch(); 10c5ca: e8 39 37 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); 10c5cf: e8 dc 7d 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c5d4: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10c5da: eb 4b jmp 10c627 <== NOT EXECUTED 10c5dc: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10c5e3: 00 00 00 <== NOT EXECUTED } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 10c5e6: 8d b8 90 00 00 00 lea 0x90(%eax),%edi <== NOT EXECUTED 10c5ec: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10c5f1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10c5f3: c7 40 7c 31 c6 10 00 movl $0x10c631,0x7c(%eax) <== NOT EXECUTED 10c5fa: 89 80 80 00 00 00 mov %eax,0x80(%eax) <== NOT EXECUTED 10c600: eb 11 jmp 10c613 <== NOT EXECUTED 10c602: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED 10c609: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10c610: 00 00 00 <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 10c613: e8 f0 36 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c618: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c61a: eb 0e jmp 10c62a <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c61c: e8 8f 7d 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c621: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10c627: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10c62a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c62d: 5e pop %esi <== NOT EXECUTED 10c62e: 5f pop %edi <== NOT EXECUTED 10c62f: c9 leave <== NOT EXECUTED 10c630: c3 ret <== NOT EXECUTED 0010c668 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 10c668: 55 push %ebp <== NOT EXECUTED 10c669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c66b: 57 push %edi <== NOT EXECUTED 10c66c: 56 push %esi <== NOT EXECUTED 10c66d: 53 push %ebx <== NOT EXECUTED 10c66e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c671: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c674: a1 38 62 12 00 mov 0x126238,%eax <== NOT EXECUTED 10c679: 40 inc %eax <== NOT EXECUTED 10c67a: a3 38 62 12 00 mov %eax,0x126238 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10c67f: 89 f8 mov %edi,%eax <== NOT EXECUTED 10c681: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10c686: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10c689: 75 09 jne 10c694 <== NOT EXECUTED 10c68b: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10c692: eb 06 jmp 10c69a <== NOT EXECUTED va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 10c694: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10c697: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10c69a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c69d: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c6a2: e8 11 2a 00 00 call 10f0b8 <_Objects_Allocate> <== NOT EXECUTED 10c6a7: 89 c3 mov %eax,%ebx <== NOT EXECUTED va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 10c6a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6ac: 85 c0 test %eax,%eax <== NOT EXECUTED 10c6ae: 75 18 jne 10c6c8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10c6b0: e8 53 36 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 10c6b5: e8 f6 7c 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c6ba: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 10c6c0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c6c3: e9 03 01 00 00 jmp 10c7cb <== NOT EXECUTED } the_mq_fd->oflag = oflag; 10c6c8: 89 78 14 mov %edi,0x14(%eax) <== NOT EXECUTED status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10c6cb: 50 push %eax <== NOT EXECUTED 10c6cc: 50 push %eax <== NOT EXECUTED 10c6cd: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c6d0: 50 push %eax <== NOT EXECUTED 10c6d1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c6d4: e8 17 5e 00 00 call 1124f0 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10c6d9: 89 c6 mov %eax,%esi <== NOT EXECUTED * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10c6db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6de: 85 c0 test %eax,%eax <== NOT EXECUTED 10c6e0: 74 2a je 10c70c <== NOT EXECUTED /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10c6e2: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c6e5: 75 0a jne 10c6f1 <== NOT EXECUTED 10c6e7: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED 10c6eb: 0f 85 8e 00 00 00 jne 10c77f <== 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 10c6f1: 57 push %edi <== NOT EXECUTED 10c6f2: 57 push %edi <== NOT EXECUTED 10c6f3: 53 push %ebx <== NOT EXECUTED 10c6f4: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c6f9: e8 ca 2c 00 00 call 10f3c8 <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10c6fe: e8 05 36 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10c703: e8 a8 7c 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c708: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10c70a: eb 2b jmp 10c737 <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10c70c: 81 e7 00 0a 00 00 and $0xa00,%edi <== NOT EXECUTED 10c712: 81 ff 00 0a 00 00 cmp $0xa00,%edi <== NOT EXECUTED 10c718: 75 28 jne 10c742 <== NOT EXECUTED 10c71a: 51 push %ecx <== NOT EXECUTED 10c71b: 51 push %ecx <== NOT EXECUTED 10c71c: 53 push %ebx <== NOT EXECUTED 10c71d: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c722: e8 a1 2c 00 00 call 10f3c8 <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10c727: e8 dc 35 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10c72c: e8 7f 7c 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c731: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10c737: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c73a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c73d: e9 89 00 00 00 jmp 10c7cb <== 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 10c742: 52 push %edx <== NOT EXECUTED 10c743: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10c746: 50 push %eax <== NOT EXECUTED 10c747: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c74a: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 10c74f: e8 a8 2d 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 10c754: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_mq->open_count += 1; 10c757: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED the_mq_fd->Queue = the_mq; 10c75a: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 10c75d: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c761: a1 40 67 12 00 mov 0x126740,%eax <== NOT EXECUTED 10c766: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c769: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10c770: e8 93 35 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c775: e8 8e 35 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 10c77a: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10c77d: eb bb jmp 10c73a <== NOT EXECUTED /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 10c77f: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c782: 50 push %eax <== NOT EXECUTED 10c783: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10c786: 6a 01 push $0x1 <== NOT EXECUTED 10c788: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c78b: e8 f4 5b 00 00 call 112384 <_POSIX_Message_queue_Create_support> <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 10c790: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c793: 40 inc %eax <== NOT EXECUTED 10c794: 75 14 jne 10c7aa <== NOT EXECUTED _Thread_Enable_dispatch(); 10c796: e8 6d 35 00 00 call 10fd08 <_Thread_Enable_dispatch> <== 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 10c79b: 50 push %eax <== NOT EXECUTED 10c79c: 50 push %eax <== NOT EXECUTED 10c79d: 53 push %ebx <== NOT EXECUTED 10c79e: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10c7a3: e8 20 2c 00 00 call 10f3c8 <_Objects_Free> <== NOT EXECUTED 10c7a8: eb 8d jmp 10c737 <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 10c7aa: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c7ad: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 10c7b0: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c7b4: a1 40 67 12 00 mov 0x126740,%eax <== NOT EXECUTED 10c7b9: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c7bc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10c7c3: e8 40 35 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t) the_mq_fd->Object.id; 10c7c8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED } 10c7cb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7ce: 5b pop %ebx <== NOT EXECUTED 10c7cf: 5e pop %esi <== NOT EXECUTED 10c7d0: 5f pop %edi <== NOT EXECUTED 10c7d1: c9 leave <== NOT EXECUTED 10c7d2: c3 ret <== NOT EXECUTED 0010c7d4 : mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio ) { 10c7d4: 55 push %ebp <== NOT EXECUTED 10c7d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7d7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Receive_support( 10c7da: 6a 00 push $0x0 <== NOT EXECUTED 10c7dc: 6a 01 push $0x1 <== NOT EXECUTED 10c7de: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c7e1: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c7e4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c7e7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c7ea: e8 05 00 00 00 call 10c7f4 <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10c7ef: c9 leave <== NOT EXECUTED 10c7f0: c3 ret <== NOT EXECUTED 0010c8ec : mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio ) { 10c8ec: 55 push %ebp <== NOT EXECUTED 10c8ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8ef: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Send_support( 10c8f2: 6a 00 push $0x0 <== NOT EXECUTED 10c8f4: 6a 01 push $0x1 <== NOT EXECUTED 10c8f6: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c8f9: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c8fc: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c8ff: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c902: e8 05 00 00 00 call 10c90c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10c907: c9 leave <== NOT EXECUTED 10c908: c3 ret <== NOT EXECUTED 0010c9dc : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 10c9dc: 55 push %ebp <== NOT EXECUTED 10c9dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9df: 56 push %esi <== NOT EXECUTED 10c9e0: 53 push %ebx <== NOT EXECUTED 10c9e1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10c9e4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c9e7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) 10c9ea: 85 f6 test %esi,%esi <== NOT EXECUTED 10c9ec: 75 0d jne 10c9fb <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c9ee: e8 bd 79 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10c9f3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c9f9: eb 54 jmp 10ca4f <== NOT EXECUTED 10c9fb: 50 push %eax <== NOT EXECUTED 10c9fc: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10c9ff: 50 push %eax <== NOT EXECUTED 10ca00: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca03: 68 24 67 12 00 push $0x126724 <== NOT EXECUTED 10ca08: e8 ef 2a 00 00 call 10f4fc <_Objects_Get> <== NOT EXECUTED 10ca0d: 89 c1 mov %eax,%ecx <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10ca0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca12: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10ca16: 75 2c jne 10ca44 <== NOT EXECUTED case OBJECTS_LOCAL: the_core_mq = &the_mq_fd->Queue->Message_queue; 10ca18: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 10ca1b: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca1d: 74 17 je 10ca36 <== NOT EXECUTED omqstat->mq_flags = the_mq_fd->oflag; 10ca1f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ca22: 89 03 mov %eax,(%ebx) <== NOT EXECUTED omqstat->mq_msgsize = the_core_mq->maximum_message_size; 10ca24: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10ca27: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 10ca2a: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10ca2d: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 10ca30: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10ca33: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED } the_mq_fd->oflag = mqstat->mq_flags; 10ca36: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10ca38: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10ca3b: e8 c8 32 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca40: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca42: eb 0e jmp 10ca52 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10ca44: e8 67 79 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10ca49: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10ca4f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10ca52: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca55: 5b pop %ebx <== NOT EXECUTED 10ca56: 5e pop %esi <== NOT EXECUTED 10ca57: c9 leave <== NOT EXECUTED 10ca58: c3 ret <== NOT EXECUTED 0010ca5c : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 10ca5c: 55 push %ebp <== NOT EXECUTED 10ca5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca5f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 10ca62: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ca65: 50 push %eax <== NOT EXECUTED 10ca66: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10ca69: e8 e2 00 00 00 call 10cb50 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10ca6e: 5a pop %edx <== NOT EXECUTED 10ca6f: 59 pop %ecx <== NOT EXECUTED 10ca70: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ca73: 0f 97 c0 seta %al <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 10ca76: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10ca79: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10ca7c: 50 push %eax <== NOT EXECUTED 10ca7d: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10ca80: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10ca83: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ca86: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca89: e8 66 fd ff ff call 10c7f4 <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10ca8e: c9 leave <== NOT EXECUTED 10ca8f: c3 ret <== NOT EXECUTED 0010ca90 : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 10ca90: 55 push %ebp <== NOT EXECUTED 10ca91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca93: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 10ca96: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ca99: 50 push %eax <== NOT EXECUTED 10ca9a: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10ca9d: e8 ae 00 00 00 call 10cb50 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10caa2: 5a pop %edx <== NOT EXECUTED 10caa3: 59 pop %ecx <== NOT EXECUTED 10caa4: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10caa7: 0f 97 c0 seta %al <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 10caaa: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10caad: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10cab0: 50 push %eax <== NOT EXECUTED 10cab1: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10cab4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10cab7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10caba: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cabd: e8 4a fe ff ff call 10c90c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10cac2: c9 leave <== NOT EXECUTED 10cac3: c3 ret <== NOT EXECUTED 0010cad4 : */ int mq_unlink( const char *name ) { 10cad4: 55 push %ebp <== NOT EXECUTED 10cad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cad7: 53 push %ebx <== NOT EXECUTED 10cad8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10cadb: a1 38 62 12 00 mov 0x126238,%eax <== NOT EXECUTED 10cae0: 40 inc %eax <== NOT EXECUTED 10cae1: a3 38 62 12 00 mov %eax,0x126238 <== NOT EXECUTED register POSIX_Message_queue_Control *the_mq; Objects_Id the_mq_id; _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10cae6: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cae9: 50 push %eax <== NOT EXECUTED 10caea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10caed: e8 fe 59 00 00 call 1124f0 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10caf2: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10caf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10caf7: 85 c0 test %eax,%eax <== NOT EXECUTED 10caf9: 74 11 je 10cb0c <== NOT EXECUTED _Thread_Enable_dispatch(); 10cafb: e8 08 32 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10cb00: e8 ab 78 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10cb05: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10cb07: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cb0a: eb 3c jmp 10cb48 <== NOT EXECUTED } the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 10cb0c: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb0f: 31 db xor %ebx,%ebx <== NOT EXECUTED 10cb11: 66 3b 05 b8 65 12 00 cmp 0x1265b8,%ax <== NOT EXECUTED 10cb18: 77 0b ja 10cb25 <== NOT EXECUTED * This heap routine returns information about the free blocks * in the specified heap. 10cb1a: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10cb1d: a1 c4 65 12 00 mov 0x1265c4,%eax <== NOT EXECUTED 10cb22: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Message_queue_Information, _Objects_Get_index( the_mq_id ) ); the_mq->linked = FALSE; 10cb25: c6 43 15 00 movb $0x0,0x15(%ebx) <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 10cb29: 50 push %eax <== NOT EXECUTED 10cb2a: 50 push %eax <== NOT EXECUTED 10cb2b: 53 push %ebx <== NOT EXECUTED 10cb2c: 68 a8 65 12 00 push $0x1265a8 <== NOT EXECUTED 10cb31: e8 da 2a 00 00 call 10f610 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 10cb36: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cb39: e8 92 f9 ff ff call 10c4d0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10cb3e: e8 c5 31 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cb43: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cb45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10cb48: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb4b: c9 leave <== NOT EXECUTED 10cb4c: c3 ret <== NOT EXECUTED 00112438 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 112438: 55 push %ebp <== NOT EXECUTED 112439: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11243b: 56 push %esi <== NOT EXECUTED 11243c: 53 push %ebx <== NOT EXECUTED 11243d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 112440: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 112443: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112446: 53 push %ebx <== NOT EXECUTED 112447: e8 10 16 00 00 call 113a5c <_Timespec_Is_valid> <== NOT EXECUTED 11244c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11244f: 84 c0 test %al,%al <== NOT EXECUTED 112451: 74 0b je 11245e <== NOT EXECUTED * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) 112453: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 112456: 78 06 js 11245e <== NOT EXECUTED 112458: 83 7b 04 00 cmpl $0x0,0x4(%ebx) <== NOT EXECUTED 11245c: 79 10 jns 11246e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 11245e: e8 d9 37 00 00 call 115c3c <__errno> <== NOT EXECUTED 112463: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 112469: e9 c3 00 00 00 jmp 112531 <== NOT EXECUTED ticks = _Timespec_To_ticks( rqtp ); 11246e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112471: 53 push %ebx <== NOT EXECUTED 112472: e8 09 16 00 00 call 113a80 <_Timespec_To_ticks> <== NOT EXECUTED 112477: 89 c3 mov %eax,%ebx <== NOT EXECUTED * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 112479: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11247c: 85 c0 test %eax,%eax <== NOT EXECUTED 11247e: 75 2f jne 1124af <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112480: a1 5c 99 12 00 mov 0x12995c,%eax <== NOT EXECUTED 112485: 40 inc %eax <== NOT EXECUTED 112486: a3 5c 99 12 00 mov %eax,0x12995c <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 11248b: e8 2c cb ff ff call 10efbc <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 112490: e8 33 c0 ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( rmtp ) { 112495: 85 f6 test %esi,%esi <== NOT EXECUTED 112497: 0f 84 99 00 00 00 je 112536 <== NOT EXECUTED rmtp->tv_sec = 0; 11249d: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED rmtp->tv_nsec = 0; 1124a3: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED 1124aa: e9 87 00 00 00 jmp 112536 <== NOT EXECUTED 1124af: a1 5c 99 12 00 mov 0x12995c,%eax <== NOT EXECUTED 1124b4: 40 inc %eax <== NOT EXECUTED 1124b5: a3 5c 99 12 00 mov %eax,0x12995c <== NOT EXECUTED /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 1124ba: 50 push %eax <== NOT EXECUTED 1124bb: 50 push %eax <== NOT EXECUTED 1124bc: 68 08 00 00 10 push $0x10000008 <== NOT EXECUTED 1124c1: ff 35 1c 9a 12 00 pushl 0x129a1c <== NOT EXECUTED 1124c7: e8 18 c8 ff ff call 10ece4 <_Thread_Set_state> <== NOT EXECUTED _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 1124cc: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 1124d1: 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. * 1124d4: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1124db: c7 40 64 4c e3 10 00 movl $0x10e34c,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1124e2: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 1124e5: 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, 1124ec: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 1124ef: 5a pop %edx <== NOT EXECUTED 1124f0: 59 pop %ecx <== NOT EXECUTED 1124f1: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1124f4: 50 push %eax <== NOT EXECUTED 1124f5: 68 3c 9a 12 00 push $0x129a3c <== NOT EXECUTED 1124fa: e8 1d ce ff ff call 10f31c <_Watchdog_Insert> <== NOT EXECUTED _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); 1124ff: e8 c4 bf ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED /* calculate time remaining */ if ( rmtp ) { 112504: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112507: 85 f6 test %esi,%esi <== NOT EXECUTED 112509: 74 2b je 112536 <== NOT EXECUTED ticks -= 11250b: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 112510: 03 58 5c add 0x5c(%eax),%ebx <== NOT EXECUTED 112513: 2b 58 60 sub 0x60(%eax),%ebx <== NOT EXECUTED _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 112516: 50 push %eax <== NOT EXECUTED 112517: 50 push %eax <== NOT EXECUTED 112518: 56 push %esi <== NOT EXECUTED 112519: 53 push %ebx <== NOT EXECUTED 11251a: e8 11 15 00 00 call 113a30 <_Timespec_From_ticks> <== NOT EXECUTED /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 11251f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112522: 85 db test %ebx,%ebx <== NOT EXECUTED 112524: 74 10 je 112536 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); 112526: e8 11 37 00 00 call 115c3c <__errno> <== NOT EXECUTED 11252b: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED 112531: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 112534: eb 02 jmp 112538 <== NOT EXECUTED 112536: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 112538: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11253b: 5b pop %ebx <== NOT EXECUTED 11253c: 5e pop %esi <== NOT EXECUTED 11253d: c9 leave <== NOT EXECUTED 11253e: c3 ret <== 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 17 8b 00 00 call 10f3a4 <== 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 40 89 00 00 call 10f204 <== 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 00106a5f : rtems_device_driver null_close( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a5f: 55 push %ebp <== NOT EXECUTED 106a60: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a62: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a64: c9 leave <== NOT EXECUTED 106a65: c3 ret <== NOT EXECUTED 00106a81 : rtems_device_driver null_control( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a81: 55 push %ebp <== NOT EXECUTED 106a82: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a84: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a86: c9 leave <== NOT EXECUTED 106a87: c3 ret <== NOT EXECUTED 00106a88 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a88: 55 push %ebp <== NOT EXECUTED 106a89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106a8b: 53 push %ebx <== NOT EXECUTED 106a8c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 106a8f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_device_driver status; if ( !initialized ) { 106a92: 80 3d 44 0e 12 00 00 cmpb $0x0,0x120e44 <== NOT EXECUTED 106a99: 75 2b jne 106ac6 <== NOT EXECUTED initialized = 1; 106a9b: c6 05 44 0e 12 00 01 movb $0x1,0x120e44 <== NOT EXECUTED status = rtems_io_register_name( 106aa2: 50 push %eax <== NOT EXECUTED 106aa3: 6a 00 push $0x0 <== NOT EXECUTED 106aa5: 53 push %ebx <== NOT EXECUTED 106aa6: 68 51 9c 11 00 push $0x119c51 <== NOT EXECUTED 106aab: e8 f5 00 00 00 call 106ba5 <== NOT EXECUTED "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 106ab0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ab3: 85 c0 test %eax,%eax <== NOT EXECUTED 106ab5: 74 09 je 106ac0 <== NOT EXECUTED rtems_fatal_error_occurred(status); 106ab7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106aba: 50 push %eax <== NOT EXECUTED 106abb: e8 20 38 00 00 call 10a2e0 <== NOT EXECUTED NULL_major = major; 106ac0: 89 1d 58 10 12 00 mov %ebx,0x121058 <== NOT EXECUTED } return RTEMS_SUCCESSFUL; } 106ac6: 31 c0 xor %eax,%eax <== NOT EXECUTED 106ac8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106acb: c9 leave <== NOT EXECUTED 106acc: c3 ret <== NOT EXECUTED 00106a58 : rtems_device_driver null_open( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a58: 55 push %ebp <== NOT EXECUTED 106a59: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a5b: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a5d: c9 leave <== NOT EXECUTED 106a5e: c3 ret <== NOT EXECUTED 00106a66 : rtems_device_driver null_read( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a66: 55 push %ebp <== NOT EXECUTED 106a67: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a69: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a6b: c9 leave <== NOT EXECUTED 106a6c: c3 ret <== NOT EXECUTED 00106a6d : rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a6d: 55 push %ebp <== NOT EXECUTED 106a6e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106a70: 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 ) 106a73: 85 d2 test %edx,%edx <== NOT EXECUTED 106a75: 74 06 je 106a7d <== NOT EXECUTED rw_args->bytes_moved = rw_args->count; 106a77: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 106a7a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a7d: 31 c0 xor %eax,%eax <== NOT EXECUTED 106a7f: c9 leave <== NOT EXECUTED 106a80: 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 f4 63 00 00 call 10cfa1 <== 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 e1 84 00 00 call 10f0b8 <__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 ab 84 00 00 call 10f0b8 <__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 c8 63 00 00 call 10d033 <== 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 18 d5 11 00 sub 0x11d518,%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 4a 60 00 00 call 10cd20 <== 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 d4 83 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 106ce4: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 106ce7: 74 07 je 106cf0 <== NOT EXECUTED 106ce9: e8 ca 83 00 00 call 10f0b8 <__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 18 d5 11 00 mov 0x11d518,%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 90 5f 00 00 call 10cc9c <== 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 1f 62 00 00 call 10cf4c <== 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 68 83 00 00 call 10f0b8 <__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 18 d5 11 00 mov 0x11d518,%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 60 11 00 push $0x116013 <== 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 60 11 00 push $0x116013 <== 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 60 11 00 push $0x116013 <== 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 e9 2b 00 00 call 109768 <== NOT EXECUTED } 106b7f: c9 leave <== NOT EXECUTED 106b80: c3 ret <== NOT EXECUTED 00120334 : * open a directory. */ DIR * opendir( const char *name ) { 120334: 55 push %ebp <== NOT EXECUTED 120335: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120337: 56 push %esi <== NOT EXECUTED 120338: 53 push %ebx <== NOT EXECUTED register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 120339: 52 push %edx <== NOT EXECUTED 12033a: 52 push %edx <== NOT EXECUTED 12033b: 6a 00 push $0x0 <== NOT EXECUTED 12033d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120340: e8 d7 a9 fe ff call 10ad1c <== NOT EXECUTED 120345: 89 c6 mov %eax,%esi <== NOT EXECUTED 120347: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12034a: 31 db xor %ebx,%ebx <== NOT EXECUTED 12034c: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 12034f: 74 62 je 1203b3 <== NOT EXECUTED return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 120351: 50 push %eax <== NOT EXECUTED 120352: 6a 01 push $0x1 <== NOT EXECUTED 120354: 6a 02 push $0x2 <== NOT EXECUTED 120356: 56 push %esi <== NOT EXECUTED 120357: e8 f0 95 00 00 call 12994c <== NOT EXECUTED 12035c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12035f: 40 inc %eax <== NOT EXECUTED 120360: 74 31 je 120393 <== NOT EXECUTED 120362: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120365: 6a 18 push $0x18 <== NOT EXECUTED 120367: e8 70 a1 fe ff call 10a4dc <== NOT EXECUTED 12036c: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12036e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120371: 85 c0 test %eax,%eax <== NOT EXECUTED 120373: 74 1e je 120393 <== 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); 120375: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120378: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 12037d: e8 5a a1 fe ff call 10a4dc <== NOT EXECUTED 120382: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED dirp->dd_len = 512; 120385: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx) <== NOT EXECUTED if (dirp->dd_buf == NULL) { 12038c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12038f: 85 c0 test %eax,%eax <== NOT EXECUTED 120391: 75 10 jne 1203a3 <== NOT EXECUTED close (fd); 120393: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120396: 56 push %esi <== NOT EXECUTED 120397: e8 64 9a fe ff call 109e00 <== NOT EXECUTED 12039c: 31 db xor %ebx,%ebx <== NOT EXECUTED 12039e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1203a1: eb 10 jmp 1203b3 <== NOT EXECUTED return NULL; } dirp->dd_fd = fd; 1203a3: 89 33 mov %esi,(%ebx) <== NOT EXECUTED dirp->dd_loc = 0; 1203a5: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED dirp->dd_seek = 0; 1203ac: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED /* * Set up seek point for rewinddir. */ return dirp; } 1203b3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1203b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1203b8: 5b pop %ebx <== NOT EXECUTED 1203b9: 5e pop %esi <== NOT EXECUTED 1203ba: c9 leave <== NOT EXECUTED 1203bb: 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 71 11 00 push $0x117193 <== 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 71 11 00 push $0x117195 <== 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 e0 b5 11 00 mov 0x11b5e0,%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 e0 b5 11 00 mov 0x11b5e0,%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 00108070 : long pathconf( const char *path, int name ) { 108070: 55 push %ebp <== NOT EXECUTED 108071: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108073: 56 push %esi <== NOT EXECUTED 108074: 53 push %ebx <== NOT EXECUTED int status; int fd; fd = open( path, O_RDONLY ); 108075: 52 push %edx <== NOT EXECUTED 108076: 52 push %edx <== NOT EXECUTED 108077: 6a 00 push $0x0 <== NOT EXECUTED 108079: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10807c: e8 db fd ff ff call 107e5c <== NOT EXECUTED 108081: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( fd == -1 ) 108083: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108086: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 108089: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10808c: 74 18 je 1080a6 <== NOT EXECUTED return -1; status = fpathconf( fd, name ); 10808e: 50 push %eax <== NOT EXECUTED 10808f: 50 push %eax <== NOT EXECUTED 108090: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108093: 53 push %ebx <== NOT EXECUTED 108094: e8 cf f1 ff ff call 107268 <== NOT EXECUTED 108099: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 10809b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10809e: e8 85 ed ff ff call 106e28 <== NOT EXECUTED 1080a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 1080a6: 89 f0 mov %esi,%eax <== NOT EXECUTED 1080a8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1080ab: 5b pop %ebx <== NOT EXECUTED 1080ac: 5e pop %esi <== NOT EXECUTED 1080ad: c9 leave <== NOT EXECUTED 1080ae: c3 ret <== NOT EXECUTED 0010a814 : /* * 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81 */ int pause( void ) { 10a814: 55 push %ebp <== NOT EXECUTED 10a815: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a817: 53 push %ebx <== NOT EXECUTED 10a818: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED sigset_t all_signals; int status; (void) sigfillset( &all_signals ); 10a81b: 8d 5d f8 lea -0x8(%ebp),%ebx <== NOT EXECUTED 10a81e: 53 push %ebx <== NOT EXECUTED 10a81f: e8 38 09 00 00 call 10b15c <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10a824: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a827: 6a 00 push $0x0 <== NOT EXECUTED 10a829: 6a 00 push $0x0 <== NOT EXECUTED 10a82b: 53 push %ebx <== NOT EXECUTED 10a82c: e8 90 0a 00 00 call 10b2c1 <== NOT EXECUTED return status; } 10a831: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a834: c9 leave <== NOT EXECUTED 10a835: c3 ret <== NOT EXECUTED 001080b0 : #include int pipe( int filsdes[2] ) { 1080b0: 55 push %ebp <== NOT EXECUTED 1080b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1080b3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED errno = ENOSYS; 1080b6: e8 ed 8e 00 00 call 110fa8 <__errno> <== NOT EXECUTED 1080bb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED return -1; } 1080c1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1080c4: c9 leave <== NOT EXECUTED 1080c5: 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 bc 18 12 00 incl 0x1218bc <== 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 00109208 : int pthread_atfork( void (*prepare)(void), void (*parent)(void), void (*child)(void) ) { 109208: 55 push %ebp <== NOT EXECUTED 109209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10920b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10920e: e8 c1 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109213: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109219: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10921c: c9 leave <== NOT EXECUTED 10921d: c3 ret <== NOT EXECUTED 0010c990 : #include int pthread_attr_destroy( pthread_attr_t *attr ) { 10c990: 55 push %ebp <== NOT EXECUTED 10c991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c993: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10c996: 85 c0 test %eax,%eax <== NOT EXECUTED 10c998: 74 0f je 10c9a9 <== NOT EXECUTED 10c99a: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10c99d: 74 0a je 10c9a9 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10c99f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10c9a5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c9a7: eb 05 jmp 10c9ae <== NOT EXECUTED return 0; 10c9a9: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10c9ae: c9 leave <== NOT EXECUTED 10c9af: c3 ret <== NOT EXECUTED 0010cf4c : int pthread_attr_getcputime( pthread_attr_t *attr, int *clock_allowed ) { 10cf4c: 55 push %ebp <== NOT EXECUTED 10cf4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cf52: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !clock_allowed ) 10cf55: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf57: 74 12 je 10cf6b <== NOT EXECUTED 10cf59: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10cf5c: 74 0d je 10cf6b <== NOT EXECUTED 10cf5e: 85 d2 test %edx,%edx <== NOT EXECUTED 10cf60: 74 09 je 10cf6b <== NOT EXECUTED return EINVAL; *clock_allowed = attr->cputime_clock_allowed; 10cf62: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10cf65: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cf67: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cf69: eb 05 jmp 10cf70 <== NOT EXECUTED return 0; 10cf6b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10cf70: c9 leave <== NOT EXECUTED 10cf71: c3 ret <== NOT EXECUTED 0010c9b0 : int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { 10c9b0: 55 push %ebp <== NOT EXECUTED 10c9b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c9b6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !detachstate ) 10c9b9: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9bb: 74 12 je 10c9cf <== NOT EXECUTED 10c9bd: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10c9c0: 74 0d je 10c9cf <== NOT EXECUTED 10c9c2: 85 d2 test %edx,%edx <== NOT EXECUTED 10c9c4: 74 09 je 10c9cf <== NOT EXECUTED return EINVAL; *detachstate = attr->detachstate; 10c9c6: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 10c9c9: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c9cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c9cd: eb 05 jmp 10c9d4 <== NOT EXECUTED return 0; 10c9cf: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10c9d4: c9 leave <== NOT EXECUTED 10c9d5: c3 ret <== NOT EXECUTED 0010c9d8 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10c9d8: 55 push %ebp <== NOT EXECUTED 10c9d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c9de: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !inheritsched ) 10c9e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9e3: 74 12 je 10c9f7 <== NOT EXECUTED 10c9e5: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10c9e8: 74 0d je 10c9f7 <== NOT EXECUTED 10c9ea: 85 d2 test %edx,%edx <== NOT EXECUTED 10c9ec: 74 09 je 10c9f7 <== NOT EXECUTED return EINVAL; *inheritsched = attr->inheritsched; 10c9ee: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10c9f1: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c9f3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c9f5: eb 05 jmp 10c9fc <== NOT EXECUTED return 0; 10c9f7: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10c9fc: c9 leave <== NOT EXECUTED 10c9fd: c3 ret <== NOT EXECUTED 0010ca00 : int pthread_attr_getschedparam( const pthread_attr_t *attr, struct sched_param *param ) { 10ca00: 55 push %ebp <== NOT EXECUTED 10ca01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca03: 57 push %edi <== NOT EXECUTED 10ca04: 56 push %esi <== NOT EXECUTED 10ca05: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ca08: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca0b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10ca0e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca10: 74 17 je 10ca29 <== NOT EXECUTED 10ca12: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10ca15: 74 12 je 10ca29 <== NOT EXECUTED 10ca17: 85 ff test %edi,%edi <== NOT EXECUTED 10ca19: 74 0e je 10ca29 <== NOT EXECUTED return EINVAL; *param = attr->schedparam; 10ca1b: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10ca1e: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ca23: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ca25: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca27: eb 05 jmp 10ca2e <== NOT EXECUTED return 0; 10ca29: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ca2e: 5a pop %edx <== NOT EXECUTED 10ca2f: 5e pop %esi <== NOT EXECUTED 10ca30: 5f pop %edi <== NOT EXECUTED 10ca31: c9 leave <== NOT EXECUTED 10ca32: c3 ret <== NOT EXECUTED 0010ca34 : int pthread_attr_getschedpolicy( const pthread_attr_t *attr, int *policy ) { 10ca34: 55 push %ebp <== NOT EXECUTED 10ca35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca37: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca3a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !policy ) 10ca3d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca3f: 74 12 je 10ca53 <== NOT EXECUTED 10ca41: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10ca44: 74 0d je 10ca53 <== NOT EXECUTED 10ca46: 85 d2 test %edx,%edx <== NOT EXECUTED 10ca48: 74 09 je 10ca53 <== NOT EXECUTED return EINVAL; *policy = attr->schedpolicy; 10ca4a: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ca4d: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ca4f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca51: eb 05 jmp 10ca58 <== NOT EXECUTED return 0; 10ca53: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ca58: c9 leave <== NOT EXECUTED 10ca59: c3 ret <== NOT EXECUTED 0010ca5c : int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) { 10ca5c: 55 push %ebp <== NOT EXECUTED 10ca5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca5f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca62: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !contentionscope ) 10ca65: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca67: 74 12 je 10ca7b <== NOT EXECUTED 10ca69: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10ca6c: 74 0d je 10ca7b <== NOT EXECUTED 10ca6e: 85 d2 test %edx,%edx <== NOT EXECUTED 10ca70: 74 09 je 10ca7b <== NOT EXECUTED return EINVAL; *contentionscope = attr->contentionscope; 10ca72: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10ca75: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ca77: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca79: eb 05 jmp 10ca80 <== NOT EXECUTED return 0; 10ca7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ca80: c9 leave <== NOT EXECUTED 10ca81: c3 ret <== NOT EXECUTED 0010ca84 : int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) { 10ca84: 55 push %ebp <== NOT EXECUTED 10ca85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca87: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca8a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stackaddr ) 10ca8d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca8f: 74 12 je 10caa3 <== NOT EXECUTED 10ca91: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10ca94: 74 0d je 10caa3 <== NOT EXECUTED 10ca96: 85 d2 test %edx,%edx <== NOT EXECUTED 10ca98: 74 09 je 10caa3 <== NOT EXECUTED return EINVAL; *stackaddr = attr->stackaddr; 10ca9a: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ca9d: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ca9f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10caa1: eb 05 jmp 10caa8 <== NOT EXECUTED return 0; 10caa3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10caa8: c9 leave <== NOT EXECUTED 10caa9: c3 ret <== NOT EXECUTED 0010caac : int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) { 10caac: 55 push %ebp <== NOT EXECUTED 10caad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caaf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cab2: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stacksize ) 10cab5: 85 c0 test %eax,%eax <== NOT EXECUTED 10cab7: 74 12 je 10cacb <== NOT EXECUTED 10cab9: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10cabc: 74 0d je 10cacb <== NOT EXECUTED 10cabe: 85 d2 test %edx,%edx <== NOT EXECUTED 10cac0: 74 09 je 10cacb <== NOT EXECUTED return EINVAL; *stacksize = attr->stacksize; 10cac2: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10cac5: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cac7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cac9: eb 05 jmp 10cad0 <== NOT EXECUTED return 0; 10cacb: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10cad0: c9 leave <== NOT EXECUTED 10cad1: c3 ret <== NOT EXECUTED 0010f1d8 : #include int pthread_attr_init( pthread_attr_t *attr ) { 10f1d8: 55 push %ebp <== NOT EXECUTED 10f1d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f1db: 57 push %edi <== NOT EXECUTED 10f1dc: 56 push %esi <== NOT EXECUTED 10f1dd: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f1e0: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 10f1e3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10f1e8: 85 ff test %edi,%edi <== NOT EXECUTED 10f1ea: 74 0e je 10f1fa <== NOT EXECUTED return EINVAL; *attr = _POSIX_Threads_Default_attributes; 10f1ec: be 90 a8 11 00 mov $0x11a890,%esi <== NOT EXECUTED 10f1f1: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10f1f6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10f1f8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10f1fa: 5a pop %edx <== NOT EXECUTED 10f1fb: 5e pop %esi <== NOT EXECUTED 10f1fc: 5f pop %edi <== NOT EXECUTED 10f1fd: c9 leave <== NOT EXECUTED 10f1fe: c3 ret <== NOT EXECUTED 0010d3f4 : int pthread_attr_setcputime( pthread_attr_t *attr, int clock_allowed ) { 10d3f4: 55 push %ebp <== NOT EXECUTED 10d3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3f7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d3fa: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10d3fd: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3ff: 74 11 je 10d412 <== NOT EXECUTED 10d401: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10d404: 74 0c je 10d412 <== NOT EXECUTED return EINVAL; switch ( clock_allowed ) { 10d406: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10d409: 77 07 ja 10d412 <== NOT EXECUTED case CLOCK_ENABLED: case CLOCK_DISABLED: attr->cputime_clock_allowed = clock_allowed; 10d40b: 89 50 30 mov %edx,0x30(%eax) <== NOT EXECUTED 10d40e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d410: eb 05 jmp 10d417 <== NOT EXECUTED return 0; 10d412: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10d417: c9 leave <== NOT EXECUTED 10d418: c3 ret <== NOT EXECUTED 0010cafc : int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) { 10cafc: 55 push %ebp <== NOT EXECUTED 10cafd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cb02: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10cb05: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb07: 74 11 je 10cb1a <== NOT EXECUTED 10cb09: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10cb0c: 74 0c je 10cb1a <== NOT EXECUTED return EINVAL; switch ( detachstate ) { 10cb0e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10cb11: 77 07 ja 10cb1a <== NOT EXECUTED case PTHREAD_CREATE_DETACHED: case PTHREAD_CREATE_JOINABLE: attr->detachstate = detachstate; 10cb13: 89 50 34 mov %edx,0x34(%eax) <== NOT EXECUTED 10cb16: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cb18: eb 05 jmp 10cb1f <== NOT EXECUTED return 0; 10cb1a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10cb1f: c9 leave <== NOT EXECUTED 10cb20: c3 ret <== NOT EXECUTED 0010f200 : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 10f200: 55 push %ebp <== NOT EXECUTED 10f201: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f203: 53 push %ebx <== NOT EXECUTED 10f204: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10f207: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10f20a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f20c: 74 19 je 10f227 <== NOT EXECUTED 10f20e: 83 39 00 cmpl $0x0,(%ecx) <== NOT EXECUTED 10f211: 74 14 je 10f227 <== NOT EXECUTED return EINVAL; switch ( inheritsched ) { 10f213: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10f216: ba 86 00 00 00 mov $0x86,%edx <== NOT EXECUTED 10f21b: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10f21e: 77 0c ja 10f22c <== NOT EXECUTED case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 10f220: 89 59 10 mov %ebx,0x10(%ecx) <== NOT EXECUTED 10f223: 30 d2 xor %dl,%dl <== NOT EXECUTED 10f225: eb 05 jmp 10f22c <== NOT EXECUTED return 0; 10f227: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED default: return ENOTSUP; } } 10f22c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f22e: 5b pop %ebx <== NOT EXECUTED 10f22f: c9 leave <== NOT EXECUTED 10f230: c3 ret <== NOT EXECUTED 0010cb58 : int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param ) { 10cb58: 55 push %ebp <== NOT EXECUTED 10cb59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb5b: 57 push %edi <== NOT EXECUTED 10cb5c: 56 push %esi <== NOT EXECUTED 10cb5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cb60: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10cb63: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb65: 74 17 je 10cb7e <== NOT EXECUTED 10cb67: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10cb6a: 74 12 je 10cb7e <== NOT EXECUTED 10cb6c: 85 f6 test %esi,%esi <== NOT EXECUTED 10cb6e: 74 0e je 10cb7e <== NOT EXECUTED return EINVAL; attr->schedparam = *param; 10cb70: 8d 78 18 lea 0x18(%eax),%edi <== NOT EXECUTED 10cb73: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10cb78: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10cb7a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cb7c: eb 05 jmp 10cb83 <== NOT EXECUTED return 0; 10cb7e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10cb83: 5e pop %esi <== NOT EXECUTED 10cb84: 5f pop %edi <== NOT EXECUTED 10cb85: c9 leave <== NOT EXECUTED 10cb86: c3 ret <== NOT EXECUTED 0010cb88 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10cb88: 55 push %ebp <== NOT EXECUTED 10cb89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb8b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cb8e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10cb91: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb93: 74 16 je 10cbab <== NOT EXECUTED 10cb95: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10cb98: 74 11 je 10cbab <== NOT EXECUTED return EINVAL; switch ( policy ) { 10cb9a: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED 10cb9f: 83 f9 03 cmp $0x3,%ecx <== NOT EXECUTED 10cba2: 77 0c ja 10cbb0 <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10cba4: 89 4a 14 mov %ecx,0x14(%edx) <== NOT EXECUTED 10cba7: 30 c0 xor %al,%al <== NOT EXECUTED 10cba9: eb 05 jmp 10cbb0 <== NOT EXECUTED return 0; 10cbab: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return ENOTSUP; } } 10cbb0: c9 leave <== NOT EXECUTED 10cbb1: c3 ret <== NOT EXECUTED 0010cbb4 : int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { 10cbb4: 55 push %ebp <== NOT EXECUTED 10cbb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cbb7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cbba: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10cbbd: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbbf: 74 1e je 10cbdf <== NOT EXECUTED 10cbc1: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10cbc4: 74 19 je 10cbdf <== NOT EXECUTED return EINVAL; switch ( contentionscope ) { 10cbc6: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbc8: 74 0a je 10cbd4 <== NOT EXECUTED 10cbca: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED 10cbcf: 4a dec %edx <== NOT EXECUTED 10cbd0: 75 0d jne 10cbdf <== NOT EXECUTED 10cbd2: eb 10 jmp 10cbe4 <== NOT EXECUTED case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; 10cbd4: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10cbdb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cbdd: eb 05 jmp 10cbe4 <== NOT EXECUTED return 0; 10cbdf: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10cbe4: c9 leave <== NOT EXECUTED 10cbe5: c3 ret <== NOT EXECUTED 0010cbe8 : int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { 10cbe8: 55 push %ebp <== NOT EXECUTED 10cbe9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cbeb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10cbee: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbf0: 74 0f je 10cc01 <== NOT EXECUTED 10cbf2: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10cbf5: 74 0a je 10cc01 <== NOT EXECUTED return EINVAL; attr->stackaddr = stackaddr; 10cbf7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cbfa: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cbfd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cbff: eb 05 jmp 10cc06 <== NOT EXECUTED return 0; 10cc01: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10cc06: c9 leave <== NOT EXECUTED 10cc07: c3 ret <== NOT EXECUTED 0010f234 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 10f234: 55 push %ebp <== NOT EXECUTED 10f235: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f237: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10f23a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10f23d: 85 d2 test %edx,%edx <== NOT EXECUTED 10f23f: 74 1c je 10f25d <== NOT EXECUTED 10f241: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10f244: 74 17 je 10f25d <== NOT EXECUTED return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 10f246: a1 e0 cb 11 00 mov 0x11cbe0,%eax <== NOT EXECUTED 10f24b: d1 e0 shl %eax <== NOT EXECUTED 10f24d: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f24f: 73 05 jae 10f256 <== NOT EXECUTED attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 10f251: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10f254: eb 03 jmp 10f259 <== NOT EXECUTED else attr->stacksize = stacksize; 10f256: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED 10f259: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f25b: eb 05 jmp 10f262 <== NOT EXECUTED 10f25d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; } 10f262: c9 leave <== NOT EXECUTED 10f263: c3 ret <== NOT EXECUTED 00109134 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 109134: 55 push %ebp <== NOT EXECUTED 109135: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109137: 53 push %ebx <== NOT EXECUTED 109138: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10913b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10913e: 85 d2 test %edx,%edx <== NOT EXECUTED 109140: 74 54 je 109196 <== 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 109142: 53 push %ebx <== NOT EXECUTED 109143: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109146: 50 push %eax <== NOT EXECUTED 109147: ff 32 pushl (%edx) <== NOT EXECUTED 109149: 68 40 ef 11 00 push $0x11ef40 <== NOT EXECUTED 10914e: e8 c9 24 00 00 call 10b61c <_Objects_Get> <== NOT EXECUTED 109153: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 109155: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109158: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10915c: 75 38 jne 109196 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 10915e: 83 78 58 00 cmpl $0x0,0x58(%eax) <== NOT EXECUTED 109162: 74 0c je 109170 <== NOT EXECUTED _Thread_Enable_dispatch(); 109164: e8 73 2c 00 00 call 10bddc <_Thread_Enable_dispatch> <== NOT EXECUTED 109169: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10916e: eb 2b jmp 10919b <== NOT EXECUTED return EBUSY; } _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); 109170: 51 push %ecx <== NOT EXECUTED 109171: 51 push %ecx <== NOT EXECUTED 109172: 50 push %eax <== NOT EXECUTED 109173: 68 40 ef 11 00 push $0x11ef40 <== NOT EXECUTED 109178: e8 cf 20 00 00 call 10b24c <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10917d: 58 pop %eax <== NOT EXECUTED 10917e: 5a pop %edx <== NOT EXECUTED 10917f: 53 push %ebx <== NOT EXECUTED 109180: 68 40 ef 11 00 push $0x11ef40 <== NOT EXECUTED 109185: e8 5e 23 00 00 call 10b4e8 <_Objects_Free> <== NOT EXECUTED _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10918a: e8 4d 2c 00 00 call 10bddc <_Thread_Enable_dispatch> <== NOT EXECUTED 10918f: 31 c0 xor %eax,%eax <== NOT EXECUTED 109191: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109194: eb 05 jmp 10919b <== NOT EXECUTED return 0; 109196: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10919b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10919e: c9 leave <== NOT EXECUTED 10919f: c3 ret <== NOT EXECUTED 001091a0 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 1091a0: 55 push %ebp <== NOT EXECUTED 1091a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091a3: 57 push %edi <== NOT EXECUTED 1091a4: 56 push %esi <== NOT EXECUTED 1091a5: 53 push %ebx <== NOT EXECUTED 1091a6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1091a9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1091ac: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 1091af: 85 ff test %edi,%edi <== NOT EXECUTED 1091b1: 0f 84 94 00 00 00 je 10924b <== NOT EXECUTED return EINVAL; if ( count == 0 ) 1091b7: 85 f6 test %esi,%esi <== NOT EXECUTED 1091b9: 0f 84 8c 00 00 00 je 10924b <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 1091bf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1091c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1091c4: 75 11 jne 1091d7 <== NOT EXECUTED the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 1091c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1091c9: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 1091cc: 53 push %ebx <== NOT EXECUTED 1091cd: e8 1a ff ff ff call 1090ec <== NOT EXECUTED 1091d2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1091d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 1091d7: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 1091da: 74 6f je 10924b <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 1091dc: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 1091e0: 75 69 jne 10924b <== NOT EXECUTED } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 1091e2: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED the_attributes.maximum_count = count; 1091e9: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1091ec: a1 50 eb 11 00 mov 0x11eb50,%eax <== NOT EXECUTED 1091f1: 40 inc %eax <== NOT EXECUTED 1091f2: a3 50 eb 11 00 mov %eax,0x11eb50 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 1091f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1091fa: 68 40 ef 11 00 push $0x11ef40 <== NOT EXECUTED 1091ff: e8 d4 1f 00 00 call 10b1d8 <_Objects_Allocate> <== NOT EXECUTED 109204: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 109206: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109209: 85 c0 test %eax,%eax <== NOT EXECUTED 10920b: 75 0c jne 109219 <== NOT EXECUTED _Thread_Enable_dispatch(); 10920d: e8 ca 2b 00 00 call 10bddc <_Thread_Enable_dispatch> <== NOT EXECUTED 109212: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 109217: eb 37 jmp 109250 <== NOT EXECUTED return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 109219: 50 push %eax <== NOT EXECUTED 10921a: 50 push %eax <== NOT EXECUTED 10921b: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10921e: 50 push %eax <== NOT EXECUTED 10921f: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 109222: 50 push %eax <== NOT EXECUTED 109223: e8 ac 17 00 00 call 10a9d4 <_CORE_barrier_Initialize> <== NOT EXECUTED 109228: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10922b: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10922e: a1 5c ef 11 00 mov 0x11ef5c,%eax <== NOT EXECUTED 109233: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109236: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10923d: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10923f: e8 98 2b 00 00 call 10bddc <_Thread_Enable_dispatch> <== NOT EXECUTED 109244: 31 c0 xor %eax,%eax <== NOT EXECUTED 109246: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109249: eb 05 jmp 109250 <== NOT EXECUTED return 0; 10924b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109250: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109253: 5b pop %ebx <== NOT EXECUTED 109254: 5e pop %esi <== NOT EXECUTED 109255: 5f pop %edi <== NOT EXECUTED 109256: c9 leave <== NOT EXECUTED 109257: c3 ret <== NOT EXECUTED 00109258 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 109258: 55 push %ebp <== NOT EXECUTED 109259: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10925b: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10925e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 109261: 85 d2 test %edx,%edx <== NOT EXECUTED 109263: 74 4c je 1092b1 <== 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 109265: 50 push %eax <== NOT EXECUTED 109266: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109269: 50 push %eax <== NOT EXECUTED 10926a: ff 32 pushl (%edx) <== NOT EXECUTED 10926c: 68 40 ef 11 00 push $0x11ef40 <== NOT EXECUTED 109271: e8 a6 23 00 00 call 10b61c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 109276: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109279: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10927d: 75 32 jne 1092b1 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 10927f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109282: 6a 00 push $0x0 <== NOT EXECUTED 109284: 6a 00 push $0x0 <== NOT EXECUTED 109286: 6a 01 push $0x1 <== NOT EXECUTED 109288: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10928b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10928e: 50 push %eax <== NOT EXECUTED 10928f: e8 74 17 00 00 call 10aa08 <_CORE_barrier_Wait> <== NOT EXECUTED the_barrier->Object.id, TRUE, 0, NULL ); _Thread_Enable_dispatch(); 109294: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109297: e8 40 2b 00 00 call 10bddc <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Barrier_Translate_core_barrier_return_code( 10929c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10929f: a1 10 ec 11 00 mov 0x11ec10,%eax <== NOT EXECUTED 1092a4: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1092a7: e8 3c 53 00 00 call 10e5e8 <_POSIX_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 1092ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1092af: eb 05 jmp 1092b6 <== NOT EXECUTED 1092b1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 1092b6: c9 leave <== NOT EXECUTED 1092b7: c3 ret <== NOT EXECUTED 001090a8 : */ int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { 1090a8: 55 push %ebp <== NOT EXECUTED 1090a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090ab: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 1090ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1090b0: 74 0f je 1090c1 <== NOT EXECUTED 1090b2: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 1090b5: 74 0a je 1090c1 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 1090b7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1090bd: 31 c0 xor %eax,%eax <== NOT EXECUTED 1090bf: eb 05 jmp 1090c6 <== NOT EXECUTED return 0; 1090c1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 1090c6: c9 leave <== NOT EXECUTED 1090c7: c3 ret <== NOT EXECUTED 001090c8 : int pthread_barrierattr_getpshared( const pthread_barrierattr_t *attr, int *pshared ) { 1090c8: 55 push %ebp <== NOT EXECUTED 1090c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 1090ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1090d0: 74 11 je 1090e3 <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 1090d2: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 1090d5: 74 0c je 1090e3 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 1090d7: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 1090da: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1090dd: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1090df: 31 c0 xor %eax,%eax <== NOT EXECUTED 1090e1: eb 05 jmp 1090e8 <== NOT EXECUTED return 0; 1090e3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 1090e8: c9 leave <== NOT EXECUTED 1090e9: c3 ret <== NOT EXECUTED 001090ec : */ int pthread_barrierattr_init( pthread_barrierattr_t *attr ) { 1090ec: 55 push %ebp <== NOT EXECUTED 1090ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090ef: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr ) 1090f2: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 1090f7: 85 d2 test %edx,%edx <== NOT EXECUTED 1090f9: 74 0f je 10910a <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 1090fb: c7 02 01 00 00 00 movl $0x1,(%edx) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 109101: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 109108: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10910a: c9 leave <== NOT EXECUTED 10910b: c3 ret <== NOT EXECUTED 0010910c : int pthread_barrierattr_setpshared( pthread_barrierattr_t *attr, int pshared ) { 10910c: 55 push %ebp <== NOT EXECUTED 10910d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10910f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109112: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr ) 109115: 85 c0 test %eax,%eax <== NOT EXECUTED 109117: 74 11 je 10912a <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 109119: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10911c: 74 0c je 10912a <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10911e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 109121: 77 07 ja 10912a <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 109123: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 109126: 31 c0 xor %eax,%eax <== NOT EXECUTED 109128: eb 05 jmp 10912f <== NOT EXECUTED return 0; 10912a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10912f: c9 leave <== NOT EXECUTED 109130: c3 ret <== NOT EXECUTED 00108a28 : */ int pthread_cancel( pthread_t thread ) { 108a28: 55 push %ebp <== NOT EXECUTED 108a29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a2b: 56 push %esi <== NOT EXECUTED 108a2c: 53 push %ebx <== NOT EXECUTED 108a2d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 108a30: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 108a35: ba 47 00 00 00 mov $0x47,%edx <== NOT EXECUTED 108a3a: 85 c0 test %eax,%eax <== NOT EXECUTED 108a3c: 75 61 jne 108a9f <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 108a3e: 52 push %edx <== NOT EXECUTED 108a3f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 108a42: 50 push %eax <== NOT EXECUTED 108a43: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108a46: 68 58 f7 11 00 push $0x11f758 <== NOT EXECUTED 108a4b: e8 98 25 00 00 call 10afe8 <_Objects_Get> <== NOT EXECUTED 108a50: 89 c6 mov %eax,%esi <== NOT EXECUTED return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 108a52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108a55: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 108a5a: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 108a5e: 75 3f jne 108a9f <== NOT EXECUTED case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 108a60: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED thread_support->cancelation_requested = 1; 108a66: c7 80 d4 00 00 00 01 movl $0x1,0xd4(%eax) <== NOT EXECUTED 108a6d: 00 00 00 <== NOT EXECUTED if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 108a70: 31 db xor %ebx,%ebx <== NOT EXECUTED 108a72: 83 b8 cc 00 00 00 00 cmpl $0x0,0xcc(%eax) <== NOT EXECUTED 108a79: 75 0a jne 108a85 <== NOT EXECUTED 108a7b: 83 b8 d0 00 00 00 01 cmpl $0x1,0xd0(%eax) <== NOT EXECUTED 108a82: 0f 94 c3 sete %bl <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 108a85: e8 1e 2d 00 00 call 10b7a8 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) 108a8a: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a8c: 84 db test %bl,%bl <== NOT EXECUTED 108a8e: 74 0f je 108a9f <== NOT EXECUTED _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 108a90: 50 push %eax <== NOT EXECUTED 108a91: 50 push %eax <== NOT EXECUTED 108a92: 6a ff push $0xffffffff <== NOT EXECUTED 108a94: 56 push %esi <== NOT EXECUTED 108a95: e8 a2 02 00 00 call 108d3c <_POSIX_Thread_Exit> <== NOT EXECUTED 108a9a: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 108a9f: 89 d0 mov %edx,%eax <== NOT EXECUTED 108aa1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108aa4: 5b pop %ebx <== NOT EXECUTED 108aa5: 5e pop %esi <== NOT EXECUTED 108aa6: c9 leave <== NOT EXECUTED 108aa7: c3 ret <== NOT EXECUTED 00108ea8 : */ void pthread_cleanup_pop( int execute ) { 108ea8: 55 push %ebp <== NOT EXECUTED 108ea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108eab: 57 push %edi <== NOT EXECUTED 108eac: 56 push %esi <== NOT EXECUTED 108ead: 53 push %ebx <== NOT EXECUTED 108eae: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108eb1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108eb4: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 108eb7: a1 40 0c 12 00 mov 0x120c40,%eax <== NOT EXECUTED 108ebc: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108ec2: a1 80 0b 12 00 mov 0x120b80,%eax <== NOT EXECUTED 108ec7: 40 inc %eax <== NOT EXECUTED 108ec8: a3 80 0b 12 00 mov %eax,0x120b80 <== NOT EXECUTED * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 108ecd: 9c pushf <== NOT EXECUTED 108ece: fa cli <== NOT EXECUTED 108ecf: 5f pop %edi <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 108ed0: 8d 82 dc 00 00 00 lea 0xdc(%edx),%eax <== NOT EXECUTED if ( _Chain_Is_empty( handler_stack ) ) { 108ed6: 39 82 d8 00 00 00 cmp %eax,0xd8(%edx) <== NOT EXECUTED 108edc: 75 09 jne 108ee7 <== NOT EXECUTED _Thread_Enable_dispatch(); 108ede: e8 29 30 00 00 call 10bf0c <_Thread_Enable_dispatch> <== NOT EXECUTED _ISR_Enable( level ); 108ee3: 57 push %edi <== NOT EXECUTED 108ee4: 9d popf <== NOT EXECUTED 108ee5: eb 4c jmp 108f33 <== NOT EXECUTED return; } handler = (POSIX_Cancel_Handler_control *) 108ee7: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 108eea: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 108eed: 8b 10 mov (%eax),%edx <== NOT EXECUTED 108eef: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 108ef2: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 108ef5: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 108ef7: 57 push %edi <== NOT EXECUTED 108ef8: 9d popf <== NOT EXECUTED tmp_handler = *handler; 108ef9: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 108efc: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 108f01: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 108f04: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 108f06: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 108f09: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED _Workspace_Free( handler ); 108f0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f0f: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 108f12: e8 0d 40 00 00 call 10cf24 <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 108f17: e8 f0 2f 00 00 call 10bf0c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( execute ) 108f1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f1f: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 108f23: 74 0e je 108f33 <== NOT EXECUTED (*tmp_handler.routine)( tmp_handler.arg ); 108f25: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED 108f28: 89 d9 mov %ebx,%ecx <== NOT EXECUTED } 108f2a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108f2d: 5b pop %ebx <== NOT EXECUTED 108f2e: 5e pop %esi <== NOT EXECUTED 108f2f: 5f pop %edi <== NOT EXECUTED 108f30: c9 leave <== NOT EXECUTED _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 108f31: ff e1 jmp *%ecx <== NOT EXECUTED } 108f33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108f36: 5b pop %ebx <== NOT EXECUTED 108f37: 5e pop %esi <== NOT EXECUTED 108f38: 5f pop %edi <== NOT EXECUTED 108f39: c9 leave <== NOT EXECUTED 108f3a: c3 ret <== NOT EXECUTED 00108f3c : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 108f3c: 55 push %ebp <== NOT EXECUTED 108f3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f3f: 56 push %esi <== NOT EXECUTED 108f40: 53 push %ebx <== NOT EXECUTED 108f41: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108f44: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 108f47: 85 db test %ebx,%ebx <== NOT EXECUTED 108f49: 74 4b je 108f96 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108f4b: a1 80 0b 12 00 mov 0x120b80,%eax <== NOT EXECUTED 108f50: 40 inc %eax <== NOT EXECUTED 108f51: a3 80 0b 12 00 mov %eax,0x120b80 <== NOT EXECUTED return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 108f56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f59: 6a 10 push $0x10 <== NOT EXECUTED 108f5b: e8 d9 3f 00 00 call 10cf39 <_Workspace_Allocate> <== NOT EXECUTED 108f60: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( handler ) { 108f62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f65: 85 c0 test %eax,%eax <== NOT EXECUTED 108f67: 74 22 je 108f8b <== NOT EXECUTED thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 108f69: a1 40 0c 12 00 mov 0x120c40,%eax <== NOT EXECUTED 108f6e: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 108f74: 05 d8 00 00 00 add $0xd8,%eax <== NOT EXECUTED handler->routine = routine; 108f79: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED handler->arg = arg; 108f7c: 89 72 0c mov %esi,0xc(%edx) <== NOT EXECUTED _Chain_Append( handler_stack, &handler->Node ); 108f7f: 51 push %ecx <== NOT EXECUTED 108f80: 51 push %ecx <== NOT EXECUTED 108f81: 52 push %edx <== NOT EXECUTED 108f82: 50 push %eax <== NOT EXECUTED 108f83: e8 e4 1b 00 00 call 10ab6c <_Chain_Append> <== NOT EXECUTED 108f88: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); } 108f8b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108f8e: 5b pop %ebx <== NOT EXECUTED 108f8f: 5e pop %esi <== NOT EXECUTED 108f90: c9 leave <== NOT EXECUTED handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 108f91: e9 76 2f 00 00 jmp 10bf0c <_Thread_Enable_dispatch> <== NOT EXECUTED } 108f96: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108f99: 5b pop %ebx <== NOT EXECUTED 108f9a: 5e pop %esi <== NOT EXECUTED 108f9b: c9 leave <== NOT EXECUTED 108f9c: c3 ret <== NOT EXECUTED 001099a4 : */ int pthread_cond_broadcast( pthread_cond_t *cond ) { 1099a4: 55 push %ebp <== NOT EXECUTED 1099a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099a7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, TRUE ); 1099aa: 6a 01 push $0x1 <== NOT EXECUTED 1099ac: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099af: e8 68 01 00 00 call 109b1c <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 1099b4: c9 leave <== NOT EXECUTED 1099b5: c3 ret <== NOT EXECUTED 001099b8 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 1099b8: 55 push %ebp <== NOT EXECUTED 1099b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099bb: 53 push %ebx <== NOT EXECUTED 1099bc: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 1099bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1099c2: 50 push %eax <== NOT EXECUTED 1099c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099c6: e8 59 00 00 00 call 109a24 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 1099cb: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 1099cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099d0: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 1099d5: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1099d9: 75 43 jne 109a1e <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 1099db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099de: 8d 43 18 lea 0x18(%ebx),%eax <== NOT EXECUTED 1099e1: 50 push %eax <== NOT EXECUTED 1099e2: e8 d1 37 00 00 call 10d1b8 <_Thread_queue_First> <== NOT EXECUTED 1099e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1099ec: 74 0c je 1099fa <== NOT EXECUTED _Thread_Enable_dispatch(); 1099ee: e8 69 31 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 1099f3: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 1099f8: eb 24 jmp 109a1e <== NOT EXECUTED return EBUSY; } _Objects_Close( 1099fa: 51 push %ecx <== NOT EXECUTED 1099fb: 51 push %ecx <== NOT EXECUTED 1099fc: 53 push %ebx <== NOT EXECUTED 1099fd: 68 b4 13 12 00 push $0x1213b4 <== NOT EXECUTED 109a02: e8 c5 25 00 00 call 10bfcc <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 109a07: 58 pop %eax <== NOT EXECUTED 109a08: 5a pop %edx <== NOT EXECUTED 109a09: 53 push %ebx <== NOT EXECUTED 109a0a: 68 b4 13 12 00 push $0x1213b4 <== NOT EXECUTED 109a0f: e8 54 28 00 00 call 10c268 <_Objects_Free> <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 109a14: e8 43 31 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109a19: 31 c0 xor %eax,%eax <== NOT EXECUTED 109a1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109a1e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109a21: c9 leave <== NOT EXECUTED 109a22: c3 ret <== NOT EXECUTED 00109a6c : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 109a6c: 55 push %ebp <== NOT EXECUTED 109a6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a6f: 56 push %esi <== NOT EXECUTED 109a70: 53 push %ebx <== NOT EXECUTED 109a71: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 109a74: be 08 a8 11 00 mov $0x11a808,%esi <== NOT EXECUTED 109a79: 85 c0 test %eax,%eax <== NOT EXECUTED 109a7b: 74 02 je 109a7f <== NOT EXECUTED 109a7d: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 109a7f: 83 7e 04 01 cmpl $0x1,0x4(%esi) <== NOT EXECUTED 109a83: 74 77 je 109afc <== NOT EXECUTED return EINVAL; if ( !the_attr->is_initialized ) 109a85: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 109a88: 74 72 je 109afc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109a8a: a1 40 0f 12 00 mov 0x120f40,%eax <== NOT EXECUTED 109a8f: 40 inc %eax <== NOT EXECUTED 109a90: a3 40 0f 12 00 mov %eax,0x120f40 <== NOT EXECUTED /**@{*/ #ifdef __cplusplus extern "C" { #endif 109a95: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a98: 68 b4 13 12 00 push $0x1213b4 <== NOT EXECUTED 109a9d: e8 b6 24 00 00 call 10bf58 <_Objects_Allocate> <== NOT EXECUTED 109aa2: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 109aa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109aa7: 85 c0 test %eax,%eax <== NOT EXECUTED 109aa9: 75 0c jne 109ab7 <== NOT EXECUTED _Thread_Enable_dispatch(); 109aab: e8 ac 30 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109ab0: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 109ab5: eb 4a jmp 109b01 <== NOT EXECUTED return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 109ab7: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 109aba: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 109abd: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 109ac4: 6a 74 push $0x74 <== NOT EXECUTED 109ac6: 68 00 08 00 00 push $0x800 <== NOT EXECUTED 109acb: 6a 00 push $0x0 <== NOT EXECUTED 109acd: 8d 43 18 lea 0x18(%ebx),%eax <== NOT EXECUTED 109ad0: 50 push %eax <== NOT EXECUTED 109ad1: e8 56 37 00 00 call 10d22c <_Thread_queue_Initialize> <== NOT EXECUTED 109ad6: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 109ad9: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 109adc: a1 d0 13 12 00 mov 0x1213d0,%eax <== NOT EXECUTED 109ae1: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109ae4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 109aeb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109aee: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 109af0: e8 67 30 00 00 call 10cb5c <_Thread_Enable_dispatch> <== NOT EXECUTED 109af5: 31 c0 xor %eax,%eax <== NOT EXECUTED 109af7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109afa: eb 05 jmp 109b01 <== NOT EXECUTED return 0; 109afc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109b01: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109b04: 5b pop %ebx <== NOT EXECUTED 109b05: 5e pop %esi <== NOT EXECUTED 109b06: c9 leave <== NOT EXECUTED 109b07: c3 ret <== NOT EXECUTED 00109b08 : */ int pthread_cond_signal( pthread_cond_t *cond ) { 109b08: 55 push %ebp <== NOT EXECUTED 109b09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b0b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, FALSE ); 109b0e: 6a 00 push $0x0 <== NOT EXECUTED 109b10: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109b13: e8 04 00 00 00 call 109b1c <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 109b18: c9 leave <== NOT EXECUTED 109b19: c3 ret <== NOT EXECUTED 00109b78 : int pthread_cond_timedwait( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime ) { 109b78: 55 push %ebp <== NOT EXECUTED 109b79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b7b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks(abstime, &ticks) ) { 109b7e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109b81: 50 push %eax <== NOT EXECUTED 109b82: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109b85: e8 0e 04 00 00 call 109f98 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 109b8a: 89 c2 mov %eax,%edx <== NOT EXECUTED 109b8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b8f: 31 c0 xor %eax,%eax <== NOT EXECUTED 109b91: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 109b94: 77 0e ja 109ba4 <== NOT EXECUTED 109b96: b0 01 mov $0x1,%al <== NOT EXECUTED 109b98: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 109b9b: 73 07 jae 109ba4 <== NOT EXECUTED 109b9d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 109ba2: eb 15 jmp 109bb9 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: already_timedout = FALSE; break; } return _POSIX_Condition_variables_Wait_support( 109ba4: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109ba7: 50 push %eax <== NOT EXECUTED 109ba8: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 109bab: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109bae: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109bb1: e8 1e 00 00 00 call 109bd4 <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED 109bb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED cond, mutex, ticks, already_timedout ); } 109bb9: c9 leave <== NOT EXECUTED 109bba: c3 ret <== NOT EXECUTED 00109bbc : int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex ) { 109bbc: 55 push %ebp <== NOT EXECUTED 109bbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109bbf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Wait_support( 109bc2: 6a 00 push $0x0 <== NOT EXECUTED 109bc4: 6a 00 push $0x0 <== NOT EXECUTED 109bc6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109bc9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109bcc: e8 03 00 00 00 call 109bd4 <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED cond, mutex, THREAD_QUEUE_WAIT_FOREVER, FALSE ); } 109bd1: c9 leave <== NOT EXECUTED 109bd2: c3 ret <== NOT EXECUTED 00109924 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 109924: 55 push %ebp <== NOT EXECUTED 109925: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109927: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10992a: 85 c0 test %eax,%eax <== NOT EXECUTED 10992c: 74 0f je 10993d <== NOT EXECUTED 10992e: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 109931: 74 0a je 10993d <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 109933: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 109939: 31 c0 xor %eax,%eax <== NOT EXECUTED 10993b: eb 05 jmp 109942 <== NOT EXECUTED return 0; 10993d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109942: c9 leave <== NOT EXECUTED 109943: c3 ret <== NOT EXECUTED 00109944 : int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { 109944: 55 push %ebp <== NOT EXECUTED 109945: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109947: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr ) 10994a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10994f: 85 d2 test %edx,%edx <== NOT EXECUTED 109951: 74 0a je 10995d <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 109953: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED 109956: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109959: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10995b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10995d: c9 leave <== NOT EXECUTED 10995e: c3 ret <== NOT EXECUTED 00109960 : */ int pthread_condattr_init( pthread_condattr_t *attr ) { 109960: 55 push %ebp <== NOT EXECUTED 109961: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109963: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED if ( !attr ) 109966: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10996b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10996d: 74 12 je 109981 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; 10996f: a1 08 a8 11 00 mov 0x11a808,%eax <== NOT EXECUTED 109974: 8b 15 0c a8 11 00 mov 0x11a80c,%edx <== NOT EXECUTED 10997a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10997c: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED 10997f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 109981: c9 leave <== NOT EXECUTED 109982: c3 ret <== NOT EXECUTED 00109984 : int pthread_condattr_setpshared( pthread_condattr_t *attr, int pshared ) { 109984: 55 push %ebp <== NOT EXECUTED 109985: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109987: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10998a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10998d: 85 d2 test %edx,%edx <== NOT EXECUTED 10998f: 74 0c je 10999d <== NOT EXECUTED return EINVAL; switch ( pshared ) { 109991: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109994: 77 07 ja 10999d <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 109996: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 109999: 31 c0 xor %eax,%eax <== NOT EXECUTED 10999b: eb 05 jmp 1099a2 <== NOT EXECUTED return 0; 10999d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 1099a2: c9 leave <== NOT EXECUTED 1099a3: c3 ret <== NOT EXECUTED 001099f8 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 1099f8: 55 push %ebp <== NOT EXECUTED 1099f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099fb: 57 push %edi <== NOT EXECUTED 1099fc: 56 push %esi <== NOT EXECUTED 1099fd: 53 push %ebx <== NOT EXECUTED 1099fe: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 109a01: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 109a04: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 109a09: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 109a0d: 0f 84 6e 02 00 00 je 109c81 <== NOT EXECUTED return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 109a13: c7 45 c8 90 a8 11 00 movl $0x11a890,-0x38(%ebp) <== NOT EXECUTED 109a1a: 85 f6 test %esi,%esi <== NOT EXECUTED 109a1c: 74 03 je 109a21 <== NOT EXECUTED 109a1e: 89 75 c8 mov %esi,-0x38(%ebp) <== NOT EXECUTED if ( !the_attr->is_initialized ) 109a21: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 109a24: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 109a27: 0f 84 4f 02 00 00 je 109c7c <== NOT EXECUTED * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 109a2d: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 109a31: 74 0f je 109a42 <== NOT EXECUTED 109a33: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109a36: 3b 05 e0 cb 11 00 cmp 0x11cbe0,%eax <== NOT EXECUTED 109a3c: 0f 82 3a 02 00 00 jb 109c7c <== NOT EXECUTED * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 109a42: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 109a45: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 109a48: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109a4b: 74 0b je 109a58 <== NOT EXECUTED 109a4d: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109a50: 0f 85 26 02 00 00 jne 109c7c <== NOT EXECUTED 109a56: eb 1c jmp 109a74 <== NOT EXECUTED case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109a58: a1 90 10 12 00 mov 0x121090,%eax <== NOT EXECUTED 109a5d: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED schedpolicy = api->schedpolicy; 109a63: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 109a66: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED schedparam = api->schedparam; 109a69: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 109a6c: 8d b0 80 00 00 00 lea 0x80(%eax),%esi <== NOT EXECUTED 109a72: eb 12 jmp 109a86 <== NOT EXECUTED break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 109a74: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 109a77: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 109a7a: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED schedparam = the_attr->schedparam; 109a7d: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 109a80: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 109a83: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 109a86: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 109a8b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 109a8d: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED 109a92: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 109a95: 83 7a 0c 00 cmpl $0x0,0xc(%edx) <== NOT EXECUTED 109a99: 0f 85 e2 01 00 00 jne 109c81 <== NOT EXECUTED /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 109a9f: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 109aa2: 8d 47 ff lea -0x1(%edi),%eax <== NOT EXECUTED 109aa5: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 109aaa: 0f 87 cc 01 00 00 ja 109c7c <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 109ab0: 83 7d d0 01 cmpl $0x1,-0x30(%ebp) <== NOT EXECUTED 109ab4: 74 24 je 109ada <== NOT EXECUTED 109ab6: 7f 10 jg 109ac8 <== NOT EXECUTED 109ab8: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 109abd: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) <== NOT EXECUTED 109ac1: 74 19 je 109adc <== NOT EXECUTED 109ac3: e9 b4 01 00 00 jmp 109c7c <== NOT EXECUTED 109ac8: 83 7d d0 02 cmpl $0x2,-0x30(%ebp) <== NOT EXECUTED 109acc: 74 12 je 109ae0 <== NOT EXECUTED 109ace: 83 7d d0 03 cmpl $0x3,-0x30(%ebp) <== NOT EXECUTED 109ad2: 0f 85 a4 01 00 00 jne 109c7c <== NOT EXECUTED 109ad8: eb 0d jmp 109ae7 <== NOT EXECUTED 109ada: 31 f6 xor %esi,%esi <== NOT EXECUTED 109adc: 31 db xor %ebx,%ebx <== NOT EXECUTED 109ade: eb 44 jmp 109b24 <== NOT EXECUTED 109ae0: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED 109ae5: eb f5 jmp 109adc <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) < 109ae7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109aea: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109aed: 50 push %eax <== NOT EXECUTED 109aee: e8 6d 39 00 00 call 10d460 <_Timespec_To_ticks> <== NOT EXECUTED 109af3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109af5: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 109af8: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109afb: e8 60 39 00 00 call 10d460 <_Timespec_To_ticks> <== NOT EXECUTED 109b00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b03: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 109b05: 0f 82 71 01 00 00 jb 109c7c <== NOT EXECUTED _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 109b0b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109b0e: 48 dec %eax <== NOT EXECUTED 109b0f: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 109b14: 0f 87 62 01 00 00 ja 109c7c <== NOT EXECUTED 109b1a: be 03 00 00 00 mov $0x3,%esi <== NOT EXECUTED 109b1f: bb bc 9f 10 00 mov $0x109fbc,%ebx <== NOT EXECUTED #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109b24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b27: ff 35 88 10 12 00 pushl 0x121088 <== NOT EXECUTED 109b2d: e8 5e 18 00 00 call 10b390 <_API_Mutex_Lock> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 109b32: c7 04 24 40 12 12 00 movl $0x121240,(%esp) <== NOT EXECUTED 109b39: e8 12 21 00 00 call 10bc50 <_Objects_Allocate> <== NOT EXECUTED 109b3e: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 109b41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b44: 85 c0 test %eax,%eax <== NOT EXECUTED 109b46: 75 05 jne 109b4d <== NOT EXECUTED _RTEMS_Unlock_allocator(); 109b48: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b4b: eb 51 jmp 109b9e <== NOT EXECUTED /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 109b4d: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 109b50: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 109b53: 50 push %eax <== NOT EXECUTED 109b54: 6a 00 push $0x0 <== NOT EXECUTED 109b56: 6a 00 push $0x0 <== NOT EXECUTED 109b58: 53 push %ebx <== NOT EXECUTED 109b59: 56 push %esi <== NOT EXECUTED 109b5a: 6a 01 push $0x1 <== NOT EXECUTED 109b5c: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 109b61: 29 f8 sub %edi,%eax <== NOT EXECUTED 109b63: 50 push %eax <== NOT EXECUTED 109b64: 6a 01 push $0x1 <== NOT EXECUTED 109b66: a1 e0 cb 11 00 mov 0x11cbe0,%eax <== NOT EXECUTED 109b6b: d1 e0 shl %eax <== NOT EXECUTED 109b6d: 39 d0 cmp %edx,%eax <== NOT EXECUTED 109b6f: 73 02 jae 109b73 <== NOT EXECUTED 109b71: 89 d0 mov %edx,%eax <== NOT EXECUTED 109b73: 50 push %eax <== NOT EXECUTED 109b74: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 109b77: ff 72 04 pushl 0x4(%edx) <== NOT EXECUTED 109b7a: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 109b7d: 68 40 12 12 00 push $0x121240 <== NOT EXECUTED 109b82: e8 91 2d 00 00 call 10c918 <_Thread_Initialize> <== NOT EXECUTED budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 109b87: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 109b8a: 84 c0 test %al,%al <== NOT EXECUTED 109b8c: 75 25 jne 109bb3 <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109b8e: 50 push %eax <== NOT EXECUTED 109b8f: 50 push %eax <== NOT EXECUTED 109b90: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 109b93: 68 40 12 12 00 push $0x121240 <== NOT EXECUTED 109b98: e8 c3 23 00 00 call 10bf60 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 109b9d: 58 pop %eax <== NOT EXECUTED 109b9e: ff 35 88 10 12 00 pushl 0x121088 <== NOT EXECUTED 109ba4: e8 2f 18 00 00 call 10b3d8 <_API_Mutex_Unlock> <== NOT EXECUTED 109ba9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 109bae: e9 c4 00 00 00 jmp 109c77 <== NOT EXECUTED /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109bb3: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 109bb6: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx <== NOT EXECUTED api->Attributes = *the_attr; 109bbc: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 109bc1: 89 df mov %ebx,%edi <== NOT EXECUTED 109bc3: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 109bc6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = the_attr->detachstate; 109bc8: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 109bcb: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 109bce: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED api->schedpolicy = schedpolicy; 109bd1: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 109bd4: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED api->schedparam = schedparam; 109bd7: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 109bdd: 8d 75 dc lea -0x24(%ebp),%esi <== NOT EXECUTED 109be0: b1 06 mov $0x6,%cl <== NOT EXECUTED 109be2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = true; 109be4: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED 109be7: c6 42 75 01 movb $0x1,0x75(%edx) <== NOT EXECUTED /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 109beb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109bee: 6a 00 push $0x0 <== NOT EXECUTED 109bf0: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 109bf3: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109bf6: 6a 01 push $0x1 <== NOT EXECUTED 109bf8: 52 push %edx <== NOT EXECUTED 109bf9: e8 8a 36 00 00 call 10d288 <_Thread_Start> <== NOT EXECUTED 109bfe: 89 c6 mov %eax,%esi <== NOT EXECUTED start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 109c00: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109c03: 83 7d d0 03 cmpl $0x3,-0x30(%ebp) <== NOT EXECUTED 109c07: 75 2b jne 109c34 <== NOT EXECUTED _Watchdog_Insert_ticks( 109c09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c0c: 8d 83 88 00 00 00 lea 0x88(%ebx),%eax <== NOT EXECUTED 109c12: 50 push %eax <== NOT EXECUTED 109c13: e8 48 38 00 00 call 10d460 <_Timespec_To_ticks> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 109c18: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 109c1e: 59 pop %ecx <== NOT EXECUTED 109c1f: 5f pop %edi <== NOT EXECUTED 109c20: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 109c26: 50 push %eax <== NOT EXECUTED 109c27: 68 b0 10 12 00 push $0x1210b0 <== NOT EXECUTED 109c2c: e8 37 3b 00 00 call 10d768 <_Watchdog_Insert> <== NOT EXECUTED 109c31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 109c34: 89 f0 mov %esi,%eax <== NOT EXECUTED 109c36: 84 c0 test %al,%al <== NOT EXECUTED 109c38: 75 22 jne 109c5c <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109c3a: 52 push %edx <== NOT EXECUTED 109c3b: 52 push %edx <== NOT EXECUTED 109c3c: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 109c3f: 68 40 12 12 00 push $0x121240 <== NOT EXECUTED 109c44: e8 17 23 00 00 call 10bf60 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 109c49: 58 pop %eax <== NOT EXECUTED 109c4a: ff 35 88 10 12 00 pushl 0x121088 <== NOT EXECUTED 109c50: e8 83 17 00 00 call 10b3d8 <_API_Mutex_Unlock> <== NOT EXECUTED 109c55: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 109c5a: eb 1b jmp 109c77 <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 109c5c: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 109c5f: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 109c62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109c65: 89 10 mov %edx,(%eax) <== NOT EXECUTED _RTEMS_Unlock_allocator(); 109c67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c6a: ff 35 88 10 12 00 pushl 0x121088 <== NOT EXECUTED 109c70: e8 63 17 00 00 call 10b3d8 <_API_Mutex_Unlock> <== NOT EXECUTED 109c75: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c7a: eb 05 jmp 109c81 <== NOT EXECUTED return 0; 109c7c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109c81: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109c84: 5b pop %ebx <== NOT EXECUTED 109c85: 5e pop %esi <== NOT EXECUTED 109c86: 5f pop %edi <== NOT EXECUTED 109c87: c9 leave <== NOT EXECUTED 109c88: c3 ret <== NOT EXECUTED 00109110 : #include int pthread_detach( pthread_t thread ) { 109110: 55 push %ebp <== NOT EXECUTED 109111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109113: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 109116: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109119: 50 push %eax <== NOT EXECUTED 10911a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10911d: 68 e8 00 12 00 push $0x1200e8 <== NOT EXECUTED 109122: e8 c1 21 00 00 call 10b2e8 <_Objects_Get> <== NOT EXECUTED 109127: 89 c2 mov %eax,%edx <== NOT EXECUTED register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 109129: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10912c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109131: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 109135: 75 14 jne 10914b <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 109137: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED 10913d: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 109144: e8 5f 29 00 00 call 10baa8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109149: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10914b: c9 leave <== NOT EXECUTED 10914c: c3 ret <== NOT EXECUTED 00109c8c : int pthread_equal( pthread_t t1, pthread_t t2 ) { 109c8c: 55 push %ebp <== NOT EXECUTED 109c8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c8f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109c92: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 109c95: 0f 94 c0 sete %al <== NOT EXECUTED 109c98: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED break; } return status; #endif } 109c9b: c9 leave <== NOT EXECUTED 109c9c: c3 ret <== NOT EXECUTED 0010ec48 : } void pthread_exit( void *value_ptr ) { 10ec48: 55 push %ebp <== NOT EXECUTED 10ec49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 10ec4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec51: ff 35 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 10ec57: e8 88 ff ff ff call 10ebe4 <_POSIX_Thread_Exit> <== NOT EXECUTED 10ec5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ec5f: c9 leave <== NOT EXECUTED 10ec60: c3 ret <== NOT EXECUTED 00109220 : int pthread_getcpuclockid( pthread_t pid, clockid_t *clock_id ) { 109220: 55 push %ebp <== NOT EXECUTED 109221: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109223: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 109226: e8 a9 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 10922b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109231: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109234: c9 leave <== NOT EXECUTED 109235: c3 ret <== NOT EXECUTED 0010aea0 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10aea0: 55 push %ebp <== NOT EXECUTED 10aea1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aea3: 57 push %edi <== NOT EXECUTED 10aea4: 56 push %esi <== NOT EXECUTED 10aea5: 53 push %ebx <== NOT EXECUTED 10aea6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10aea9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10aeac: 85 f6 test %esi,%esi <== NOT EXECUTED 10aeae: 74 06 je 10aeb6 <== NOT EXECUTED 10aeb0: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10aeb4: 75 07 jne 10aebd <== NOT EXECUTED 10aeb6: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10aebb: eb 51 jmp 10af0e <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10aebd: 50 push %eax <== NOT EXECUTED 10aebe: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10aec1: 50 push %eax <== NOT EXECUTED 10aec2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aec5: 68 b8 2c 12 00 push $0x122cb8 <== NOT EXECUTED 10aeca: e8 6d 22 00 00 call 10d13c <_Objects_Get> <== NOT EXECUTED 10aecf: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10aed1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aed4: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10aed9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10aedd: 75 2f jne 10af0e <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10aedf: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx <== NOT EXECUTED if ( policy ) *policy = api->schedpolicy; 10aee5: 8b 42 7c mov 0x7c(%edx),%eax <== NOT EXECUTED 10aee8: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( param ) { *param = api->schedparam; 10aeea: 8d b2 80 00 00 00 lea 0x80(%edx),%esi <== NOT EXECUTED 10aef0: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10aef5: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10aef8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED param->sched_priority = 10aefa: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10aeff: 2b 43 14 sub 0x14(%ebx),%eax <== NOT EXECUTED 10af02: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10af05: 89 02 mov %eax,(%edx) <== NOT EXECUTED _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10af07: e8 f0 29 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10af0c: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return ESRCH; } 10af0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af11: 5b pop %ebx <== NOT EXECUTED 10af12: 5e pop %esi <== NOT EXECUTED 10af13: 5f pop %edi <== NOT EXECUTED 10af14: c9 leave <== NOT EXECUTED 10af15: c3 ret <== NOT EXECUTED 00109044 : */ void *pthread_getspecific( pthread_key_t key ) { 109044: 55 push %ebp <== NOT EXECUTED 109045: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109047: 53 push %ebx <== NOT EXECUTED 109048: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10904b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10904e: 50 push %eax <== NOT EXECUTED 10904f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109052: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 109057: e8 20 24 00 00 call 10b47c <_Objects_Get> <== NOT EXECUTED 10905c: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10905e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109061: 31 db xor %ebx,%ebx <== NOT EXECUTED 109063: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109067: 75 22 jne 10908b <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 109069: a1 28 00 12 00 mov 0x120028,%eax <== NOT EXECUTED 10906e: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 109071: 89 d0 mov %edx,%eax <== NOT EXECUTED 109073: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 109076: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 109079: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10907f: 8b 44 81 18 mov 0x18(%ecx,%eax,4),%eax <== NOT EXECUTED 109083: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 109086: e8 b1 2b 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED case OBJECTS_ERROR: break; } return NULL; } 10908b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10908d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109090: c9 leave <== NOT EXECUTED 109091: c3 ret <== NOT EXECUTED 0010d060 : int pthread_join( pthread_t thread, void **value_ptr ) { 10d060: 55 push %ebp <== NOT EXECUTED 10d061: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d063: 56 push %esi <== NOT EXECUTED 10d064: 53 push %ebx <== NOT EXECUTED 10d065: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d068: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d06b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10d06e: 50 push %eax <== NOT EXECUTED 10d06f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d072: 68 a4 6c 12 00 push $0x126ca4 <== NOT EXECUTED 10d077: e8 58 22 00 00 call 10f2d4 <_Objects_Get> <== NOT EXECUTED 10d07c: 89 c3 mov %eax,%ebx <== NOT EXECUTED POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10d07e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d081: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10d086: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10d08a: 75 61 jne 10d0ed <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d08c: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx <== NOT EXECUTED if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 10d092: 83 7a 38 00 cmpl $0x0,0x38(%edx) <== NOT EXECUTED 10d096: 75 0c jne 10d0a4 <== NOT EXECUTED _Thread_Enable_dispatch(); 10d098: e8 f7 29 00 00 call 10fa94 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d09d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10d0a2: eb 49 jmp 10d0ed <== NOT EXECUTED 10d0a4: 8b 0d f4 6a 12 00 mov 0x126af4,%ecx <== NOT EXECUTED return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 10d0aa: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10d0ac: 75 0c jne 10d0ba <== NOT EXECUTED _Thread_Enable_dispatch(); 10d0ae: e8 e1 29 00 00 call 10fa94 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d0b3: b8 2d 00 00 00 mov $0x2d,%eax <== NOT EXECUTED 10d0b8: eb 33 jmp 10d0ed <== NOT EXECUTED /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 10d0ba: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d0bd: 89 41 28 mov %eax,0x28(%ecx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10d0c0: c7 42 6c 01 00 00 00 movl $0x1,0x6c(%edx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 10d0c7: 50 push %eax <== NOT EXECUTED 10d0c8: 68 e8 01 11 00 push $0x1101e8 <== NOT EXECUTED 10d0cd: 6a 00 push $0x0 <== NOT EXECUTED 10d0cf: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10d0d2: 50 push %eax <== NOT EXECUTED 10d0d3: e8 0c 2e 00 00 call 10fee4 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10d0d8: e8 b7 29 00 00 call 10fa94 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( value_ptr ) 10d0dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d0e0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d0e2: 85 f6 test %esi,%esi <== NOT EXECUTED 10d0e4: 74 07 je 10d0ed <== NOT EXECUTED *value_ptr = return_pointer; 10d0e6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d0e9: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d0eb: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10d0ed: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d0f0: 5b pop %ebx <== NOT EXECUTED 10d0f1: 5e pop %esi <== NOT EXECUTED 10d0f2: c9 leave <== NOT EXECUTED 10d0f3: c3 ret <== NOT EXECUTED 00108e9c : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 108e9c: 55 push %ebp <== NOT EXECUTED 108e9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e9f: 57 push %edi <== NOT EXECUTED 108ea0: 56 push %esi <== NOT EXECUTED 108ea1: 53 push %ebx <== NOT EXECUTED 108ea2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 108ea5: a1 68 ff 11 00 mov 0x11ff68,%eax <== NOT EXECUTED 108eaa: 40 inc %eax <== NOT EXECUTED 108eab: a3 68 ff 11 00 mov %eax,0x11ff68 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 108eb0: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 108eb5: e8 7e 21 00 00 call 10b038 <_Objects_Allocate> <== NOT EXECUTED 108eba: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 108ebd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ec0: 85 c0 test %eax,%eax <== NOT EXECUTED 108ec2: 75 0f jne 108ed3 <== NOT EXECUTED _Thread_Enable_dispatch(); 108ec4: e8 73 2d 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED 108ec9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 108ece: e9 c4 00 00 00 jmp 108f97 <== NOT EXECUTED return EAGAIN; } the_key->destructor = destructor; 108ed3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108ed6: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108ed9: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 108edc: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] ) { 108ee1: 8b 04 9d 3c ff 11 00 mov 0x11ff3c(,%ebx,4),%eax <== NOT EXECUTED 108ee8: 85 c0 test %eax,%eax <== NOT EXECUTED 108eea: 74 6e je 108f5a <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 108eec: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 108eef: 0f b7 40 10 movzwl 0x10(%eax),%eax <== NOT EXECUTED 108ef3: 8d 34 85 04 00 00 00 lea 0x4(,%eax,4),%esi <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 108efa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108efd: 56 push %esi <== NOT EXECUTED 108efe: e8 d2 3d 00 00 call 10ccd5 <_Workspace_Allocate> <== NOT EXECUTED 108f03: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !table ) { 108f05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f08: 85 c0 test %eax,%eax <== NOT EXECUTED 108f0a: 75 3f jne 108f4b <== NOT EXECUTED for ( --the_api; 108f0c: 8d 73 ff lea -0x1(%ebx),%esi <== NOT EXECUTED 108f0f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 108f12: 8d 5c 98 14 lea 0x14(%eax,%ebx,4),%ebx <== NOT EXECUTED 108f16: eb 11 jmp 108f29 <== NOT EXECUTED the_api >= 1; the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); 108f18: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f1b: ff 33 pushl (%ebx) <== NOT EXECUTED 108f1d: e8 9e 3d 00 00 call 10ccc0 <_Workspace_Free> <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; the_api-- ) 108f22: 4e dec %esi <== NOT EXECUTED 108f23: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED 108f26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 108f29: 85 f6 test %esi,%esi <== NOT EXECUTED 108f2b: 75 eb jne 108f18 <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 108f2d: 50 push %eax <== NOT EXECUTED 108f2e: 50 push %eax <== NOT EXECUTED 108f2f: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 108f32: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 108f37: e8 0c 24 00 00 call 10b348 <_Objects_Free> <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 108f3c: e8 fb 2c 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED 108f41: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 108f46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f49: eb 4c jmp 108f97 <== NOT EXECUTED return ENOMEM; } the_key->Values[ the_api ] = table; 108f4b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108f4e: 89 44 9a 18 mov %eax,0x18(%edx,%ebx,4) <== NOT EXECUTED memset( table, '\0', bytes_to_allocate ); 108f52: 89 f1 mov %esi,%ecx <== NOT EXECUTED 108f54: 31 c0 xor %eax,%eax <== NOT EXECUTED 108f56: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 108f58: eb 0b jmp 108f65 <== NOT EXECUTED } else { the_key->Values[ the_api ] = NULL; 108f5a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108f5d: c7 44 9a 18 00 00 00 movl $0x0,0x18(%edx,%ebx,4) <== NOT EXECUTED 108f64: 00 <== NOT EXECUTED * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 108f65: 43 inc %ebx <== NOT EXECUTED * APIs are optional. Thus there may be no ITRON tasks to have keys * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 108f66: 83 fb 05 cmp $0x5,%ebx <== NOT EXECUTED 108f69: 0f 85 72 ff ff ff jne 108ee1 <== NOT EXECUTED } } the_key->is_active = TRUE; 108f6f: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 108f72: c6 43 10 01 movb $0x1,0x10(%ebx) <== NOT EXECUTED 108f76: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 108f79: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 108f7c: a1 b8 03 12 00 mov 0x1203b8,%eax <== NOT EXECUTED 108f81: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 108f84: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 108f8b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108f8e: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 108f90: e8 a7 2c 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED 108f95: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 108f97: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108f9a: 5b pop %ebx <== NOT EXECUTED 108f9b: 5e pop %esi <== NOT EXECUTED 108f9c: 5f pop %edi <== NOT EXECUTED 108f9d: c9 leave <== NOT EXECUTED 108f9e: c3 ret <== NOT EXECUTED 00108fa0 : */ int pthread_key_delete( pthread_key_t key ) { 108fa0: 55 push %ebp <== NOT EXECUTED 108fa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fa3: 53 push %ebx <== NOT EXECUTED 108fa4: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 108fa7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 108faa: 50 push %eax <== NOT EXECUTED 108fab: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108fae: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 108fb3: e8 c4 24 00 00 call 10b47c <_Objects_Get> <== NOT EXECUTED 108fb8: 89 c3 mov %eax,%ebx <== NOT EXECUTED register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 108fba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fbd: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 108fc2: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 108fc6: 75 77 jne 10903f <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 108fc8: 52 push %edx <== NOT EXECUTED 108fc9: 52 push %edx <== NOT EXECUTED 108fca: 53 push %ebx <== NOT EXECUTED 108fcb: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 108fd0: e8 d7 20 00 00 call 10b0ac <_Objects_Close> <== NOT EXECUTED the_key->is_active = FALSE; 108fd5: c6 43 10 00 movb $0x0,0x10(%ebx) <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 108fd9: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 108fdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fdf: 85 c0 test %eax,%eax <== NOT EXECUTED 108fe1: 74 0c je 108fef <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 108fe3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fe6: 50 push %eax <== NOT EXECUTED 108fe7: e8 d4 3c 00 00 call 10ccc0 <_Workspace_Free> <== NOT EXECUTED 108fec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 108fef: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108ff2: 85 c0 test %eax,%eax <== NOT EXECUTED 108ff4: 74 0c je 109002 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 108ff6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ff9: 50 push %eax <== NOT EXECUTED 108ffa: e8 c1 3c 00 00 call 10ccc0 <_Workspace_Free> <== NOT EXECUTED 108fff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 109002: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 109005: 85 c0 test %eax,%eax <== NOT EXECUTED 109007: 74 0c je 109015 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 109009: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10900c: 50 push %eax <== NOT EXECUTED 10900d: e8 ae 3c 00 00 call 10ccc0 <_Workspace_Free> <== NOT EXECUTED 109012: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 109015: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109018: 85 c0 test %eax,%eax <== NOT EXECUTED 10901a: 74 0c je 109028 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10901c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10901f: 50 push %eax <== NOT EXECUTED 109020: e8 9b 3c 00 00 call 10ccc0 <_Workspace_Free> <== NOT EXECUTED 109025: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109028: 50 push %eax <== NOT EXECUTED 109029: 50 push %eax <== NOT EXECUTED 10902a: 53 push %ebx <== NOT EXECUTED 10902b: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 109030: e8 13 23 00 00 call 10b348 <_Objects_Free> <== NOT EXECUTED * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 109035: e8 02 2c 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED 10903a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10903c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10903f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109042: c9 leave <== NOT EXECUTED 109043: c3 ret <== NOT EXECUTED 0011e3cc : int pthread_kill( pthread_t thread, int sig ) { 11e3cc: 55 push %ebp <== NOT EXECUTED 11e3cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e3cf: 57 push %edi <== NOT EXECUTED 11e3d0: 56 push %esi <== NOT EXECUTED 11e3d1: 53 push %ebx <== NOT EXECUTED 11e3d2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11e3d5: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 11e3d8: 85 f6 test %esi,%esi <== NOT EXECUTED 11e3da: 74 08 je 11e3e4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 11e3dc: 8d 7e ff lea -0x1(%esi),%edi <== NOT EXECUTED 11e3df: 83 ff 1f cmp $0x1f,%edi <== NOT EXECUTED 11e3e2: 76 0d jbe 11e3f1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 11e3e4: e8 53 78 ff ff call 115c3c <__errno> <== NOT EXECUTED 11e3e9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11e3ef: eb 7b jmp 11e46c <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 11e3f1: 52 push %edx <== NOT EXECUTED 11e3f2: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11e3f5: 50 push %eax <== NOT EXECUTED 11e3f6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11e3f9: 68 0c 9c 12 00 push $0x129c0c <== NOT EXECUTED 11e3fe: e8 05 f9 fe ff call 10dd08 <_Objects_Get> <== NOT EXECUTED 11e403: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 11e405: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e408: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 11e40c: 75 53 jne 11e461 <== NOT EXECUTED case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11e40e: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 11e414: 6b c6 0c imul $0xc,%esi,%eax <== NOT EXECUTED 11e417: 83 b8 80 9f 12 00 01 cmpl $0x1,0x129f80(%eax) <== NOT EXECUTED 11e41e: 74 38 je 11e458 <== NOT EXECUTED return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 11e420: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11e425: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11e427: d3 e0 shl %cl,%eax <== NOT EXECUTED 11e429: 09 82 c8 00 00 00 or %eax,0xc8(%edx) <== NOT EXECUTED (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 11e42f: 50 push %eax <== NOT EXECUTED 11e430: 6a 00 push $0x0 <== NOT EXECUTED 11e432: 56 push %esi <== NOT EXECUTED 11e433: 53 push %ebx <== NOT EXECUTED 11e434: e8 a3 fe ff ff call 11e2dc <_POSIX_signals_Unblock_thread> <== NOT EXECUTED the_thread->do_post_task_switch_extension = true; 11e439: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11e43d: a1 f8 99 12 00 mov 0x1299f8,%eax <== NOT EXECUTED 11e442: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11e445: 85 c0 test %eax,%eax <== NOT EXECUTED 11e447: 74 0f je 11e458 <== NOT EXECUTED 11e449: 3b 1d 1c 9a 12 00 cmp 0x129a1c,%ebx <== NOT EXECUTED 11e44f: 75 07 jne 11e458 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 11e451: c6 05 b0 9a 12 00 01 movb $0x1,0x129ab0 <== NOT EXECUTED } _Thread_Enable_dispatch(); 11e458: e8 6b 00 ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 11e45d: 31 c0 xor %eax,%eax <== NOT EXECUTED 11e45f: eb 0e jmp 11e46f <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 11e461: e8 d6 77 ff ff call 115c3c <__errno> <== NOT EXECUTED 11e466: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 11e46c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 11e46f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11e472: 5b pop %ebx <== NOT EXECUTED 11e473: 5e pop %esi <== NOT EXECUTED 11e474: 5f pop %edi <== NOT EXECUTED 11e475: c9 leave <== NOT EXECUTED 11e476: c3 ret <== NOT EXECUTED 0010a728 : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 10a728: 55 push %ebp <== NOT EXECUTED 10a729: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a72b: 53 push %ebx <== NOT EXECUTED 10a72c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10a72f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a732: 50 push %eax <== NOT EXECUTED 10a733: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a736: e8 a6 00 00 00 call 10a7e1 <_POSIX_Mutex_Get> <== NOT EXECUTED 10a73b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10a73d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a740: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10a745: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a749: 75 46 jne 10a791 <== NOT EXECUTED /* * XXX: There is an error for the mutex being locked * or being in use by a condition variable. */ if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { 10a74b: 83 7b 64 00 cmpl $0x0,0x64(%ebx) <== NOT EXECUTED 10a74f: 75 0c jne 10a75d <== NOT EXECUTED _Thread_Enable_dispatch(); 10a751: e8 a6 31 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a756: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10a75b: eb 34 jmp 10a791 <== NOT EXECUTED return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); 10a75d: 51 push %ecx <== NOT EXECUTED 10a75e: 51 push %ecx <== NOT EXECUTED 10a75f: 53 push %ebx <== NOT EXECUTED 10a760: 68 f8 2d 12 00 push $0x122df8 <== NOT EXECUTED 10a765: e8 02 26 00 00 call 10cd6c <_Objects_Close> <== NOT EXECUTED _CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL ); 10a76a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a76d: 6a 16 push $0x16 <== NOT EXECUTED 10a76f: 6a 00 push $0x0 <== NOT EXECUTED 10a771: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a774: 50 push %eax <== NOT EXECUTED 10a775: e8 d6 1e 00 00 call 10c650 <_CORE_mutex_Flush> <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10a77a: 58 pop %eax <== NOT EXECUTED 10a77b: 5a pop %edx <== NOT EXECUTED 10a77c: 53 push %ebx <== NOT EXECUTED 10a77d: 68 f8 2d 12 00 push $0x122df8 <== NOT EXECUTED 10a782: e8 81 28 00 00 call 10d008 <_Objects_Free> <== NOT EXECUTED _POSIX_Mutex_Free( the_mutex ); _Thread_Enable_dispatch(); 10a787: e8 70 31 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a78c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a78e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a791: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a794: c9 leave <== NOT EXECUTED 10a795: c3 ret <== NOT EXECUTED 0010a828 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 10a828: 55 push %ebp <== NOT EXECUTED 10a829: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a82b: 53 push %ebx <== NOT EXECUTED 10a82c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a82f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 10a832: 85 db test %ebx,%ebx <== NOT EXECUTED 10a834: 74 2c je 10a862 <== NOT EXECUTED return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10a836: 50 push %eax <== NOT EXECUTED 10a837: 50 push %eax <== NOT EXECUTED 10a838: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a83b: 50 push %eax <== NOT EXECUTED 10a83c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a83f: e8 9d ff ff ff call 10a7e1 <_POSIX_Mutex_Get> <== NOT EXECUTED 10a844: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a846: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a849: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a84d: 75 13 jne 10a862 <== NOT EXECUTED case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 10a84f: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10a854: 2b 42 60 sub 0x60(%edx),%eax <== NOT EXECUTED 10a857: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); 10a859: e8 9e 30 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a85e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a860: eb 05 jmp 10a867 <== NOT EXECUTED return 0; 10a862: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a867: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a86a: c9 leave <== NOT EXECUTED 10a86b: c3 ret <== NOT EXECUTED 0010a86c : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10a86c: 55 push %ebp <== NOT EXECUTED 10a86d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a86f: 57 push %edi <== NOT EXECUTED 10a870: 56 push %esi <== NOT EXECUTED 10a871: 53 push %ebx <== NOT EXECUTED 10a872: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a875: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10a878: be a0 c2 11 00 mov $0x11c2a0,%esi <== NOT EXECUTED 10a87d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a87f: 74 02 je 10a883 <== NOT EXECUTED 10a881: 89 c6 mov %eax,%esi <== NOT EXECUTED else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10a883: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10a887: 0f 84 df 00 00 00 je 10a96c <== NOT EXECUTED break; } } #endif if ( !the_attr->is_initialized ) 10a88d: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 10a890: 0f 84 d6 00 00 00 je 10a96c <== NOT EXECUTED /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10a896: 83 7e 04 00 cmpl $0x0,0x4(%esi) <== NOT EXECUTED 10a89a: 74 16 je 10a8b2 <== NOT EXECUTED 10a89c: 68 b4 c2 11 00 push $0x11c2b4 <== NOT EXECUTED 10a8a1: 68 30 c3 11 00 push $0x11c330 <== NOT EXECUTED 10a8a6: 6a 68 push $0x68 <== NOT EXECUTED 10a8a8: 68 e8 c2 11 00 push $0x11c2e8 <== NOT EXECUTED 10a8ad: e8 86 d5 ff ff call 107e38 <__assert_func> <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10a8b2: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10a8b5: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a8b8: 74 10 je 10a8ca <== NOT EXECUTED 10a8ba: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10a8bd: 74 12 je 10a8d1 <== NOT EXECUTED 10a8bf: 31 ff xor %edi,%edi <== NOT EXECUTED 10a8c1: 85 c0 test %eax,%eax <== NOT EXECUTED 10a8c3: 74 11 je 10a8d6 <== NOT EXECUTED 10a8c5: e9 a2 00 00 00 jmp 10a96c <== NOT EXECUTED 10a8ca: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED 10a8cf: eb 05 jmp 10a8d6 <== NOT EXECUTED 10a8d1: bf 03 00 00 00 mov $0x3,%edi <== NOT EXECUTED break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10a8d6: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a8d9: 48 dec %eax <== NOT EXECUTED 10a8da: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10a8df: 0f 87 87 00 00 00 ja 10a96c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a8e5: a1 48 2a 12 00 mov 0x122a48,%eax <== NOT EXECUTED 10a8ea: 40 inc %eax <== NOT EXECUTED 10a8eb: a3 48 2a 12 00 mov %eax,0x122a48 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10a8f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8f3: 68 f8 2d 12 00 push $0x122df8 <== NOT EXECUTED 10a8f8: e8 fb 23 00 00 call 10ccf8 <_Objects_Allocate> <== NOT EXECUTED 10a8fd: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10a8ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a902: 85 c0 test %eax,%eax <== NOT EXECUTED 10a904: 75 0c jne 10a912 <== NOT EXECUTED _Thread_Enable_dispatch(); 10a906: e8 f1 2f 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a90b: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a910: eb 5f jmp 10a971 <== NOT EXECUTED return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10a912: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a915: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a918: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a91a: 83 7e 10 00 cmpl $0x0,0x10(%esi) <== NOT EXECUTED 10a91e: 0f 94 c0 sete %al <== NOT EXECUTED 10a921: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 10a924: c6 43 58 01 movb $0x1,0x58(%ebx) <== NOT EXECUTED the_mutex_attr->priority_ceiling = 10a928: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10a92d: 2b 46 08 sub 0x8(%esi),%eax <== NOT EXECUTED 10a930: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10a933: 89 7b 5c mov %edi,0x5c(%ebx) <== NOT EXECUTED /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10a936: 50 push %eax <== NOT EXECUTED 10a937: 6a 01 push $0x1 <== NOT EXECUTED 10a939: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10a93c: 50 push %eax <== NOT EXECUTED 10a93d: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a940: 50 push %eax <== NOT EXECUTED 10a941: e8 16 1d 00 00 call 10c65c <_CORE_mutex_Initialize> <== NOT EXECUTED 10a946: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a949: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a94c: a1 14 2e 12 00 mov 0x122e14,%eax <== NOT EXECUTED 10a951: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a954: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10a95b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a95e: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a960: e8 97 2f 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a965: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a96a: eb 05 jmp 10a971 <== NOT EXECUTED return 0; 10a96c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a971: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a974: 5b pop %ebx <== NOT EXECUTED 10a975: 5e pop %esi <== NOT EXECUTED 10a976: 5f pop %edi <== NOT EXECUTED 10a977: c9 leave <== NOT EXECUTED 10a978: c3 ret <== NOT EXECUTED 0010a97c : */ int pthread_mutex_lock( pthread_mutex_t *mutex ) { 10a97c: 55 push %ebp <== NOT EXECUTED 10a97d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a97f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10a982: 6a 00 push $0x0 <== NOT EXECUTED 10a984: 6a 01 push $0x1 <== NOT EXECUTED 10a986: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a989: e8 02 00 00 00 call 10a990 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10a98e: c9 leave <== NOT EXECUTED 10a98f: c3 ret <== NOT EXECUTED 0010a9ec : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 10a9ec: 55 push %ebp <== NOT EXECUTED 10a9ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a9ef: 57 push %edi <== NOT EXECUTED 10a9f0: 56 push %esi <== NOT EXECUTED 10a9f1: 53 push %ebx <== NOT EXECUTED 10a9f2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a9f5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a9f8: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 10a9fb: 85 ff test %edi,%edi <== NOT EXECUTED 10a9fd: 74 5f je 10aa5e <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10a9ff: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10aa02: 48 dec %eax <== NOT EXECUTED 10aa03: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10aa08: 77 54 ja 10aa5e <== NOT EXECUTED /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 10aa0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa0d: 56 push %esi <== NOT EXECUTED 10aa0e: e8 69 ff ff ff call 10a97c <== NOT EXECUTED 10aa13: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status ) 10aa15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa18: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa1a: 75 47 jne 10aa63 <== NOT EXECUTED return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10aa1c: 52 push %edx <== NOT EXECUTED 10aa1d: 52 push %edx <== NOT EXECUTED 10aa1e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10aa21: 50 push %eax <== NOT EXECUTED 10aa22: 56 push %esi <== NOT EXECUTED 10aa23: e8 b9 fd ff ff call 10a7e1 <_POSIX_Mutex_Get> <== NOT EXECUTED 10aa28: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10aa2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa2d: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10aa31: 75 2b jne 10aa5e <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 10aa33: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10aa38: 89 c2 mov %eax,%edx <== NOT EXECUTED 10aa3a: 2b 51 60 sub 0x60(%ecx),%edx <== NOT EXECUTED 10aa3d: 89 17 mov %edx,(%edi) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 10aa3f: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10aa42: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED _CORE_mutex_Surrender( 10aa45: 50 push %eax <== NOT EXECUTED 10aa46: 6a 00 push $0x0 <== NOT EXECUTED 10aa48: ff 71 08 pushl 0x8(%ecx) <== NOT EXECUTED 10aa4b: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 10aa4e: 50 push %eax <== NOT EXECUTED 10aa4f: e8 84 1d 00 00 call 10c7d8 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10aa54: e8 a3 2e 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10aa59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa5c: eb 05 jmp 10aa63 <== NOT EXECUTED return 0; 10aa5e: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10aa63: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aa65: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa68: 5b pop %ebx <== NOT EXECUTED 10aa69: 5e pop %esi <== NOT EXECUTED 10aa6a: 5f pop %edi <== NOT EXECUTED 10aa6b: c9 leave <== NOT EXECUTED 10aa6c: c3 ret <== NOT EXECUTED 0010aa70 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10aa70: 55 push %ebp <== NOT EXECUTED 10aa71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa73: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10aa76: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10aa79: 50 push %eax <== NOT EXECUTED 10aa7a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10aa7d: e8 96 00 00 00 call 10ab18 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10aa82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa85: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aa87: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10aa8a: 76 07 jbe 10aa93 <== NOT EXECUTED 10aa8c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aa8f: 75 02 jne 10aa93 <== NOT EXECUTED 10aa91: b2 01 mov $0x1,%dl <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10aa93: 50 push %eax <== NOT EXECUTED 10aa94: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10aa97: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 10aa9a: 50 push %eax <== NOT EXECUTED 10aa9b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa9e: e8 ed fe ff ff call 10a990 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED break; } } return lock_status; } 10aaa3: c9 leave <== NOT EXECUTED 10aaa4: c3 ret <== NOT EXECUTED 0010aab8 : */ int pthread_mutex_trylock( pthread_mutex_t *mutex ) { 10aab8: 55 push %ebp <== NOT EXECUTED 10aab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aabb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, FALSE, THREAD_QUEUE_WAIT_FOREVER ); 10aabe: 6a 00 push $0x0 <== NOT EXECUTED 10aac0: 6a 00 push $0x0 <== NOT EXECUTED 10aac2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aac5: e8 c6 fe ff ff call 10a990 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10aaca: c9 leave <== NOT EXECUTED 10aacb: c3 ret <== NOT EXECUTED 0010aacc : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 10aacc: 55 push %ebp <== NOT EXECUTED 10aacd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aacf: 53 push %ebx <== NOT EXECUTED 10aad0: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10aad3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10aad6: 50 push %eax <== NOT EXECUTED 10aad7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aada: e8 02 fd ff ff call 10a7e1 <_POSIX_Mutex_Get> <== NOT EXECUTED 10aadf: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10aae1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aae4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10aae9: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10aaed: 75 21 jne 10ab10 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 10aaef: 50 push %eax <== NOT EXECUTED 10aaf0: 6a 00 push $0x0 <== NOT EXECUTED 10aaf2: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10aaf5: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10aaf8: 50 push %eax <== NOT EXECUTED 10aaf9: e8 da 1c 00 00 call 10c7d8 <_CORE_mutex_Surrender> <== NOT EXECUTED 10aafe: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10ab00: e8 f7 2d 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Mutex_Translate_core_mutex_return_code( status ); 10ab05: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ab08: e8 9b ff ff ff call 10aaa8 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10ab0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ab10: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab13: c9 leave <== NOT EXECUTED 10ab14: c3 ret <== NOT EXECUTED 0010a5ec : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { 10a5ec: 55 push %ebp <== NOT EXECUTED 10a5ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10a5f2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a5f4: 74 0f je 10a605 <== NOT EXECUTED 10a5f6: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a5f9: 74 0a je 10a605 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10a5fb: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10a601: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a603: eb 05 jmp 10a60a <== NOT EXECUTED return 0; 10a605: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a60a: c9 leave <== NOT EXECUTED 10a60b: c3 ret <== NOT EXECUTED 0010a60c : int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t *attr, int *prioceiling ) { 10a60c: 55 push %ebp <== NOT EXECUTED 10a60d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a60f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a612: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !prioceiling ) 10a615: 85 c0 test %eax,%eax <== NOT EXECUTED 10a617: 74 12 je 10a62b <== NOT EXECUTED 10a619: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a61c: 74 0d je 10a62b <== NOT EXECUTED 10a61e: 85 d2 test %edx,%edx <== NOT EXECUTED 10a620: 74 09 je 10a62b <== NOT EXECUTED return EINVAL; *prioceiling = attr->prio_ceiling; 10a622: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a625: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a627: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a629: eb 05 jmp 10a630 <== NOT EXECUTED return 0; 10a62b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a630: c9 leave <== NOT EXECUTED 10a631: c3 ret <== NOT EXECUTED 0010a634 : int pthread_mutexattr_getprotocol( const pthread_mutexattr_t *attr, int *protocol ) { 10a634: 55 push %ebp <== NOT EXECUTED 10a635: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a637: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a63a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !protocol ) 10a63d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a63f: 74 12 je 10a653 <== NOT EXECUTED 10a641: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a644: 74 0d je 10a653 <== NOT EXECUTED 10a646: 85 d2 test %edx,%edx <== NOT EXECUTED 10a648: 74 09 je 10a653 <== NOT EXECUTED return EINVAL; *protocol = attr->protocol; 10a64a: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10a64d: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a64f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a651: eb 05 jmp 10a658 <== NOT EXECUTED return 0; 10a653: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a658: c9 leave <== NOT EXECUTED 10a659: c3 ret <== NOT EXECUTED 0010a65c : int pthread_mutexattr_getpshared( const pthread_mutexattr_t *attr, int *pshared ) { 10a65c: 55 push %ebp <== NOT EXECUTED 10a65d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a65f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a662: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !pshared ) 10a665: 85 c0 test %eax,%eax <== NOT EXECUTED 10a667: 74 12 je 10a67b <== NOT EXECUTED 10a669: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a66c: 74 0d je 10a67b <== NOT EXECUTED 10a66e: 85 d2 test %edx,%edx <== NOT EXECUTED 10a670: 74 09 je 10a67b <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10a672: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a675: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a677: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a679: eb 05 jmp 10a680 <== NOT EXECUTED return 0; 10a67b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a680: c9 leave <== NOT EXECUTED 10a681: c3 ret <== NOT EXECUTED 0010a684 : */ int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { 10a684: 55 push %ebp <== NOT EXECUTED 10a685: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a687: 57 push %edi <== NOT EXECUTED 10a688: 56 push %esi <== NOT EXECUTED 10a689: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a68c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 10a68f: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10a694: 85 ff test %edi,%edi <== NOT EXECUTED 10a696: 74 0e je 10a6a6 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Mutex_Default_attributes; 10a698: be a0 c2 11 00 mov $0x11c2a0,%esi <== NOT EXECUTED 10a69d: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10a6a2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a6a4: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a6a6: 5a pop %edx <== NOT EXECUTED 10a6a7: 5e pop %esi <== NOT EXECUTED 10a6a8: 5f pop %edi <== NOT EXECUTED 10a6a9: c9 leave <== NOT EXECUTED 10a6aa: c3 ret <== NOT EXECUTED 0010a6ac : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { 10a6ac: 55 push %ebp <== NOT EXECUTED 10a6ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a6af: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a6b2: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10a6b5: 85 d2 test %edx,%edx <== NOT EXECUTED 10a6b7: 74 16 je 10a6cf <== NOT EXECUTED 10a6b9: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10a6bc: 74 11 je 10a6cf <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10a6be: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 10a6c1: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10a6c6: 77 07 ja 10a6cf <== NOT EXECUTED return EINVAL; attr->prio_ceiling = prioceiling; 10a6c8: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED 10a6cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6cd: eb 05 jmp 10a6d4 <== NOT EXECUTED return 0; 10a6cf: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a6d4: c9 leave <== NOT EXECUTED 10a6d5: c3 ret <== NOT EXECUTED 0010a6d8 : int pthread_mutexattr_setprotocol( pthread_mutexattr_t *attr, int protocol ) { 10a6d8: 55 push %ebp <== NOT EXECUTED 10a6d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a6db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a6de: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10a6e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10a6e3: 74 11 je 10a6f6 <== NOT EXECUTED 10a6e5: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a6e8: 74 0c je 10a6f6 <== NOT EXECUTED return EINVAL; switch ( protocol ) { 10a6ea: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10a6ed: 77 07 ja 10a6f6 <== NOT EXECUTED case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; 10a6ef: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10a6f2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6f4: eb 05 jmp 10a6fb <== NOT EXECUTED return 0; 10a6f6: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10a6fb: c9 leave <== NOT EXECUTED 10a6fc: c3 ret <== NOT EXECUTED 0010a700 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10a700: 55 push %ebp <== NOT EXECUTED 10a701: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a703: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a706: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10a709: 85 c0 test %eax,%eax <== NOT EXECUTED 10a70b: 74 11 je 10a71e <== NOT EXECUTED 10a70d: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a710: 74 0c je 10a71e <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a712: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10a715: 77 07 ja 10a71e <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a717: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10a71a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a71c: eb 05 jmp 10a723 <== NOT EXECUTED return 0; 10a71e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10a723: c9 leave <== NOT EXECUTED 10a724: c3 ret <== NOT EXECUTED 0010a084 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a084: 55 push %ebp <== NOT EXECUTED 10a085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a087: 56 push %esi <== NOT EXECUTED 10a088: 53 push %ebx <== NOT EXECUTED 10a089: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a08c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a08f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED if ( !once_control || !init_routine ) 10a092: 85 db test %ebx,%ebx <== NOT EXECUTED 10a094: 74 04 je 10a09a <== NOT EXECUTED 10a096: 85 f6 test %esi,%esi <== NOT EXECUTED 10a098: 75 07 jne 10a0a1 <== NOT EXECUTED 10a09a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10a09f: eb 4b jmp 10a0ec <== NOT EXECUTED return EINVAL; if ( !once_control->init_executed ) { 10a0a1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a0a3: 83 7b 04 00 cmpl $0x0,0x4(%ebx) <== NOT EXECUTED 10a0a7: 75 43 jne 10a0ec <== NOT EXECUTED rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a0a9: 52 push %edx <== NOT EXECUTED 10a0aa: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a0ad: 50 push %eax <== NOT EXECUTED 10a0ae: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10a0b3: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10a0b8: e8 8f 0c 00 00 call 10ad4c <== NOT EXECUTED if ( !once_control->init_executed ) { 10a0bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c0: 83 7b 04 00 cmpl $0x0,0x4(%ebx) <== NOT EXECUTED 10a0c4: 75 0f jne 10a0d5 <== NOT EXECUTED once_control->is_initialized = TRUE; 10a0c6: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED once_control->init_executed = TRUE; 10a0cc: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED (*init_routine)(); 10a0d3: ff d6 call *%esi <== NOT EXECUTED } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a0d5: 50 push %eax <== NOT EXECUTED 10a0d6: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a0d9: 50 push %eax <== NOT EXECUTED 10a0da: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10a0df: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10a0e2: e8 65 0c 00 00 call 10ad4c <== NOT EXECUTED 10a0e7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a0e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10a0ec: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a0ef: 5b pop %ebx <== NOT EXECUTED 10a0f0: 5e pop %esi <== NOT EXECUTED 10a0f1: c9 leave <== NOT EXECUTED 10a0f2: c3 ret <== NOT EXECUTED 00109724 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 109724: 55 push %ebp <== NOT EXECUTED 109725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109727: 53 push %ebx <== NOT EXECUTED 109728: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10972b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 10972e: 85 d2 test %edx,%edx <== NOT EXECUTED 109730: 74 61 je 109793 <== 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 109732: 53 push %ebx <== NOT EXECUTED 109733: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109736: 50 push %eax <== NOT EXECUTED 109737: ff 32 pushl (%edx) <== NOT EXECUTED 109739: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 10973e: e8 1d 2a 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED 109743: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109745: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109748: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10974c: 75 45 jne 109793 <== NOT EXECUTED case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 10974e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109751: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 109754: 50 push %eax <== NOT EXECUTED 109755: e8 12 39 00 00 call 10d06c <_Thread_queue_First> <== NOT EXECUTED 10975a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10975d: 85 c0 test %eax,%eax <== NOT EXECUTED 10975f: 74 0c je 10976d <== NOT EXECUTED _Thread_Enable_dispatch(); 109761: e8 ba 31 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED 109766: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10976b: eb 2b jmp 109798 <== NOT EXECUTED /* * POSIX doesn't require behavior when it is locked. */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); 10976d: 51 push %ecx <== NOT EXECUTED 10976e: 51 push %ecx <== NOT EXECUTED 10976f: 53 push %ebx <== NOT EXECUTED 109770: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109775: e8 16 26 00 00 call 10bd90 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10977a: 58 pop %eax <== NOT EXECUTED 10977b: 5a pop %edx <== NOT EXECUTED 10977c: 53 push %ebx <== NOT EXECUTED 10977d: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109782: e8 a5 28 00 00 call 10c02c <_Objects_Free> <== NOT EXECUTED _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 109787: e8 94 31 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED 10978c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10978e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109791: eb 05 jmp 109798 <== NOT EXECUTED return 0; 109793: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109798: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10979b: c9 leave <== NOT EXECUTED 10979c: c3 ret <== NOT EXECUTED 001097a0 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 1097a0: 55 push %ebp <== NOT EXECUTED 1097a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097a3: 56 push %esi <== NOT EXECUTED 1097a4: 53 push %ebx <== NOT EXECUTED 1097a5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1097a8: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 1097ab: 85 f6 test %esi,%esi <== NOT EXECUTED 1097ad: 0f 84 82 00 00 00 je 109835 <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 1097b3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1097b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1097b8: 75 11 jne 1097cb <== NOT EXECUTED the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 1097ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097bd: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 1097c0: 53 push %ebx <== NOT EXECUTED 1097c1: e8 9a 09 00 00 call 10a160 <== NOT EXECUTED 1097c6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1097c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 1097cb: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 1097ce: 74 65 je 109835 <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 1097d0: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 1097d4: 75 5f jne 109835 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1097d6: a1 b0 fa 11 00 mov 0x11fab0,%eax <== NOT EXECUTED 1097db: 40 inc %eax <== NOT EXECUTED 1097dc: a3 b0 fa 11 00 mov %eax,0x11fab0 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 1097e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097e4: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 1097e9: e8 2e 25 00 00 call 10bd1c <_Objects_Allocate> <== NOT EXECUTED 1097ee: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 1097f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1097f3: 85 c0 test %eax,%eax <== NOT EXECUTED 1097f5: 75 0c jne 109803 <== NOT EXECUTED _Thread_Enable_dispatch(); 1097f7: e8 24 31 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED 1097fc: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 109801: eb 37 jmp 10983a <== NOT EXECUTED return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 109803: 50 push %eax <== NOT EXECUTED 109804: 50 push %eax <== NOT EXECUTED 109805: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109808: 50 push %eax <== NOT EXECUTED 109809: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10980c: 50 push %eax <== NOT EXECUTED 10980d: e8 ae 1e 00 00 call 10b6c0 <_CORE_RWLock_Initialize> <== NOT EXECUTED 109812: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 109815: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 109818: a1 fc fc 11 00 mov 0x11fcfc,%eax <== NOT EXECUTED 10981d: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109820: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 109827: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 109829: e8 f2 30 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED 10982e: 31 c0 xor %eax,%eax <== NOT EXECUTED 109830: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109833: eb 05 jmp 10983a <== NOT EXECUTED return 0; 109835: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10983a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10983d: 5b pop %ebx <== NOT EXECUTED 10983e: 5e pop %esi <== NOT EXECUTED 10983f: c9 leave <== NOT EXECUTED 109840: c3 ret <== NOT EXECUTED 00109844 : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 109844: 55 push %ebp <== NOT EXECUTED 109845: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109847: 53 push %ebx <== NOT EXECUTED 109848: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10984b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10984e: 85 db test %ebx,%ebx <== NOT EXECUTED 109850: 74 4b je 10989d <== 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 109852: 50 push %eax <== NOT EXECUTED 109853: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109856: 50 push %eax <== NOT EXECUTED 109857: ff 33 pushl (%ebx) <== NOT EXECUTED 109859: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 10985e: e8 fd 28 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109863: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109866: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10986a: 75 31 jne 10989d <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10986c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10986f: 6a 00 push $0x0 <== NOT EXECUTED 109871: 6a 00 push $0x0 <== NOT EXECUTED 109873: 6a 01 push $0x1 <== NOT EXECUTED 109875: ff 33 pushl (%ebx) <== NOT EXECUTED 109877: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10987a: 50 push %eax <== NOT EXECUTED 10987b: e8 74 1e 00 00 call 10b6f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED TRUE, /* we are willing to wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 109880: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109883: e8 98 30 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 109888: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10988b: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 109890: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109893: e8 70 01 00 00 call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109898: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10989b: eb 05 jmp 1098a2 <== NOT EXECUTED 10989d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 1098a2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1098a5: c9 leave <== NOT EXECUTED 1098a6: c3 ret <== NOT EXECUTED 001098a8 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 1098a8: 55 push %ebp <== NOT EXECUTED 1098a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098ab: 57 push %edi <== NOT EXECUTED 1098ac: 56 push %esi <== NOT EXECUTED 1098ad: 53 push %ebx <== NOT EXECUTED 1098ae: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1098b1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 1098b4: 85 ff test %edi,%edi <== NOT EXECUTED 1098b6: 0f 84 8e 00 00 00 je 10994a <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 1098bc: 52 push %edx <== NOT EXECUTED 1098bd: 52 push %edx <== NOT EXECUTED 1098be: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 1098c1: 50 push %eax <== NOT EXECUTED 1098c2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1098c5: e8 ee 59 00 00 call 10f2b8 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 1098ca: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (status) { 1098cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098cf: 31 db xor %ebx,%ebx <== NOT EXECUTED 1098d1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1098d4: 76 07 jbe 1098dd <== NOT EXECUTED 1098d6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 1098d9: 75 02 jne 1098dd <== NOT EXECUTED 1098db: b3 01 mov $0x1,%bl <== NOT EXECUTED 1098dd: 50 push %eax <== NOT EXECUTED 1098de: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1098e1: 50 push %eax <== NOT EXECUTED 1098e2: ff 37 pushl (%edi) <== NOT EXECUTED 1098e4: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 1098e9: e8 72 28 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED 1098ee: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 1098f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098f3: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 1098f7: 75 51 jne 10994a <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 1098f9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098fc: 6a 00 push $0x0 <== NOT EXECUTED 1098fe: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109901: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 109904: 50 push %eax <== NOT EXECUTED 109905: ff 37 pushl (%edi) <== NOT EXECUTED 109907: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 10990a: 50 push %eax <== NOT EXECUTED 10990b: e8 e4 1d 00 00 call 10b6f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 109910: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109913: e8 08 30 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 109918: 84 db test %bl,%bl <== NOT EXECUTED 10991a: 75 19 jne 109935 <== NOT EXECUTED 10991c: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 109921: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 109925: 75 0e jne 109935 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 109927: 85 f6 test %esi,%esi <== NOT EXECUTED 109929: 74 1f je 10994a <== NOT EXECUTED 10992b: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 109930: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 109933: 76 1a jbe 10994f <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 109935: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109938: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 10993d: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109940: e8 c3 00 00 00 call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109945: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109948: eb 05 jmp 10994f <== NOT EXECUTED 10994a: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10994f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109952: 5b pop %ebx <== NOT EXECUTED 109953: 5e pop %esi <== NOT EXECUTED 109954: 5f pop %edi <== NOT EXECUTED 109955: c9 leave <== NOT EXECUTED 109956: c3 ret <== NOT EXECUTED 00109958 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 109958: 55 push %ebp <== NOT EXECUTED 109959: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10995b: 57 push %edi <== NOT EXECUTED 10995c: 56 push %esi <== NOT EXECUTED 10995d: 53 push %ebx <== NOT EXECUTED 10995e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109961: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 109964: 85 ff test %edi,%edi <== NOT EXECUTED 109966: 0f 84 8e 00 00 00 je 1099fa <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10996c: 52 push %edx <== NOT EXECUTED 10996d: 52 push %edx <== NOT EXECUTED 10996e: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 109971: 50 push %eax <== NOT EXECUTED 109972: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109975: e8 3e 59 00 00 call 10f2b8 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10997a: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (status) { 10997c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10997f: 31 db xor %ebx,%ebx <== NOT EXECUTED 109981: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109984: 76 07 jbe 10998d <== NOT EXECUTED 109986: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109989: 75 02 jne 10998d <== NOT EXECUTED 10998b: b3 01 mov $0x1,%bl <== NOT EXECUTED 10998d: 50 push %eax <== NOT EXECUTED 10998e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109991: 50 push %eax <== NOT EXECUTED 109992: ff 37 pushl (%edi) <== NOT EXECUTED 109994: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109999: e8 c2 27 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED 10999e: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 1099a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099a3: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 1099a7: 75 51 jne 1099fa <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 1099a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099ac: 6a 00 push $0x0 <== NOT EXECUTED 1099ae: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1099b1: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 1099b4: 50 push %eax <== NOT EXECUTED 1099b5: ff 37 pushl (%edi) <== NOT EXECUTED 1099b7: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 1099ba: 50 push %eax <== NOT EXECUTED 1099bb: e8 e8 1d 00 00 call 10b7a8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 1099c0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1099c3: e8 58 2f 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 1099c8: 84 db test %bl,%bl <== NOT EXECUTED 1099ca: 75 19 jne 1099e5 <== NOT EXECUTED 1099cc: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 1099d1: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 1099d5: 75 0e jne 1099e5 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 1099d7: 85 f6 test %esi,%esi <== NOT EXECUTED 1099d9: 74 1f je 1099fa <== NOT EXECUTED 1099db: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 1099e0: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 1099e3: 76 1a jbe 1099ff <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 1099e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099e8: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 1099ed: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1099f0: e8 13 00 00 00 call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 1099f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099f8: eb 05 jmp 1099ff <== NOT EXECUTED 1099fa: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 1099ff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109a02: 5b pop %ebx <== NOT EXECUTED 109a03: 5e pop %esi <== NOT EXECUTED 109a04: 5f pop %edi <== NOT EXECUTED 109a05: c9 leave <== NOT EXECUTED 109a06: c3 ret <== NOT EXECUTED 00109a18 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 109a18: 55 push %ebp <== NOT EXECUTED 109a19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a1b: 53 push %ebx <== NOT EXECUTED 109a1c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109a1f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 109a22: 85 db test %ebx,%ebx <== NOT EXECUTED 109a24: 74 4b je 109a71 <== NOT EXECUTED 109a26: 50 push %eax <== NOT EXECUTED 109a27: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109a2a: 50 push %eax <== NOT EXECUTED 109a2b: ff 33 pushl (%ebx) <== NOT EXECUTED 109a2d: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109a32: e8 29 27 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109a37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a3a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109a3e: 75 31 jne 109a71 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 109a40: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a43: 6a 00 push $0x0 <== NOT EXECUTED 109a45: 6a 00 push $0x0 <== NOT EXECUTED 109a47: 6a 00 push $0x0 <== NOT EXECUTED 109a49: ff 33 pushl (%ebx) <== NOT EXECUTED 109a4b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109a4e: 50 push %eax <== NOT EXECUTED 109a4f: e8 a0 1c 00 00 call 10b6f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); 109a54: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109a57: e8 c4 2e 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 109a5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a5f: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 109a64: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109a67: e8 9c ff ff ff call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109a6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a6f: eb 05 jmp 109a76 <== NOT EXECUTED 109a71: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109a76: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109a79: c9 leave <== NOT EXECUTED 109a7a: c3 ret <== NOT EXECUTED 00109a7c : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 109a7c: 55 push %ebp <== NOT EXECUTED 109a7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a7f: 53 push %ebx <== NOT EXECUTED 109a80: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109a83: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 109a86: 85 db test %ebx,%ebx <== NOT EXECUTED 109a88: 74 4b je 109ad5 <== NOT EXECUTED 109a8a: 50 push %eax <== NOT EXECUTED 109a8b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109a8e: 50 push %eax <== NOT EXECUTED 109a8f: ff 33 pushl (%ebx) <== NOT EXECUTED 109a91: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109a96: e8 c5 26 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109a9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a9e: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109aa2: 75 31 jne 109ad5 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 109aa4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109aa7: 6a 00 push $0x0 <== NOT EXECUTED 109aa9: 6a 00 push $0x0 <== NOT EXECUTED 109aab: 6a 00 push $0x0 <== NOT EXECUTED 109aad: ff 33 pushl (%ebx) <== NOT EXECUTED 109aaf: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109ab2: 50 push %eax <== NOT EXECUTED 109ab3: e8 f0 1c 00 00 call 10b7a8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED FALSE, /* we are not willing to wait */ 0, NULL ); _Thread_Enable_dispatch(); 109ab8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109abb: e8 60 2e 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 109ac0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ac3: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 109ac8: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109acb: e8 38 ff ff ff call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109ad0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ad3: eb 05 jmp 109ada <== NOT EXECUTED 109ad5: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109ada: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109add: c9 leave <== NOT EXECUTED 109ade: c3 ret <== NOT EXECUTED 00109ae0 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 109ae0: 55 push %ebp <== NOT EXECUTED 109ae1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ae3: 53 push %ebx <== NOT EXECUTED 109ae4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109ae7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 109aea: 85 d2 test %edx,%edx <== NOT EXECUTED 109aec: 74 3a je 109b28 <== NOT EXECUTED 109aee: 50 push %eax <== NOT EXECUTED 109aef: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109af2: 50 push %eax <== NOT EXECUTED 109af3: ff 32 pushl (%edx) <== NOT EXECUTED 109af5: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109afa: e8 61 26 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109aff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b02: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109b06: 75 20 jne 109b28 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 109b08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b0b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109b0e: 50 push %eax <== NOT EXECUTED 109b0f: e8 10 1d 00 00 call 10b824 <_CORE_RWLock_Release> <== NOT EXECUTED 109b14: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 109b16: e8 05 2e 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 109b1b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109b1e: e8 e5 fe ff ff call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109b23: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b26: eb 05 jmp 109b2d <== NOT EXECUTED 109b28: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109b2d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109b30: c9 leave <== NOT EXECUTED 109b31: c3 ret <== NOT EXECUTED 00109b34 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 109b34: 55 push %ebp <== NOT EXECUTED 109b35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b37: 53 push %ebx <== NOT EXECUTED 109b38: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109b3b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 109b3e: 85 db test %ebx,%ebx <== NOT EXECUTED 109b40: 74 4b je 109b8d <== NOT EXECUTED 109b42: 50 push %eax <== NOT EXECUTED 109b43: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109b46: 50 push %eax <== NOT EXECUTED 109b47: ff 33 pushl (%ebx) <== NOT EXECUTED 109b49: 68 e0 fc 11 00 push $0x11fce0 <== NOT EXECUTED 109b4e: e8 0d 26 00 00 call 10c160 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 109b53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b56: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109b5a: 75 31 jne 109b8d <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 109b5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b5f: 6a 00 push $0x0 <== NOT EXECUTED 109b61: 6a 00 push $0x0 <== NOT EXECUTED 109b63: 6a 01 push $0x1 <== NOT EXECUTED 109b65: ff 33 pushl (%ebx) <== NOT EXECUTED 109b67: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109b6a: 50 push %eax <== NOT EXECUTED 109b6b: e8 38 1c 00 00 call 10b7a8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED TRUE, /* do not timeout -- wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 109b70: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109b73: e8 a8 2d 00 00 call 10c920 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 109b78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b7b: a1 70 fb 11 00 mov 0x11fb70,%eax <== NOT EXECUTED 109b80: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109b83: e8 80 fe ff ff call 109a08 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 109b88: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b8b: eb 05 jmp 109b92 <== NOT EXECUTED 109b8d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109b92: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109b95: c9 leave <== NOT EXECUTED 109b96: c3 ret <== NOT EXECUTED 0010a11c : */ int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { 10a11c: 55 push %ebp <== NOT EXECUTED 10a11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a11f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10a122: 85 c0 test %eax,%eax <== NOT EXECUTED 10a124: 74 0f je 10a135 <== NOT EXECUTED 10a126: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a129: 74 0a je 10a135 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10a12b: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10a131: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a133: eb 05 jmp 10a13a <== NOT EXECUTED return 0; 10a135: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a13a: c9 leave <== NOT EXECUTED 10a13b: c3 ret <== NOT EXECUTED 0010a13c : int pthread_rwlockattr_getpshared( const pthread_rwlockattr_t *attr, int *pshared ) { 10a13c: 55 push %ebp <== NOT EXECUTED 10a13d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a13f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a142: 85 c0 test %eax,%eax <== NOT EXECUTED 10a144: 74 11 je 10a157 <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a146: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a149: 74 0c je 10a157 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10a14b: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10a14e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a151: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10a153: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a155: eb 05 jmp 10a15c <== NOT EXECUTED return 0; 10a157: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a15c: c9 leave <== NOT EXECUTED 10a15d: c3 ret <== NOT EXECUTED 0010a160 : */ int pthread_rwlockattr_init( pthread_rwlockattr_t *attr ) { 10a160: 55 push %ebp <== NOT EXECUTED 10a161: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a163: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr ) 10a166: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10a16b: 85 d2 test %edx,%edx <== NOT EXECUTED 10a16d: 74 0f je 10a17e <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 10a16f: c7 02 01 00 00 00 movl $0x1,(%edx) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 10a175: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10a17c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a17e: c9 leave <== NOT EXECUTED 10a17f: c3 ret <== NOT EXECUTED 0010a180 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10a180: 55 push %ebp <== NOT EXECUTED 10a181: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a183: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a186: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr ) 10a189: 85 c0 test %eax,%eax <== NOT EXECUTED 10a18b: 74 11 je 10a19e <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a18d: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a190: 74 0c je 10a19e <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a192: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10a195: 77 07 ja 10a19e <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a197: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10a19a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a19c: eb 05 jmp 10a1a3 <== NOT EXECUTED return 0; 10a19e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10a1a3: c9 leave <== NOT EXECUTED 10a1a4: c3 ret <== NOT EXECUTED 0011e478 : #include #include pthread_t pthread_self( void ) { 11e478: 55 push %ebp <== NOT EXECUTED 11e479: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11e47b: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 11e480: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 11e483: c9 leave <== NOT EXECUTED 11e484: c3 ret <== NOT EXECUTED 00109140 : int pthread_setcancelstate( int state, int *oldstate ) { 109140: 55 push %ebp <== NOT EXECUTED 109141: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109143: 53 push %ebx <== NOT EXECUTED 109144: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109147: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10914a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10914d: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 109152: ba 47 00 00 00 mov $0x47,%edx <== NOT EXECUTED 109157: 85 c0 test %eax,%eax <== NOT EXECUTED 109159: 75 6e jne 1091c9 <== NOT EXECUTED return EPROTO; if ( !oldstate ) 10915b: 85 db test %ebx,%ebx <== NOT EXECUTED 10915d: 74 65 je 1091c4 <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 10915f: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 109162: 77 60 ja 1091c4 <== NOT EXECUTED return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109164: a1 a8 f5 11 00 mov 0x11f5a8,%eax <== NOT EXECUTED 109169: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10916f: a1 e8 f4 11 00 mov 0x11f4e8,%eax <== NOT EXECUTED 109174: 40 inc %eax <== NOT EXECUTED 109175: a3 e8 f4 11 00 mov %eax,0x11f4e8 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10917a: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax <== NOT EXECUTED 109180: 89 03 mov %eax,(%ebx) <== NOT EXECUTED thread_support->cancelability_state = state; 109182: 89 8a cc 00 00 00 mov %ecx,0xcc(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 109188: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10918a: 75 15 jne 1091a1 <== NOT EXECUTED 10918c: 83 ba d0 00 00 00 01 cmpl $0x1,0xd0(%edx) <== NOT EXECUTED 109193: 75 0c jne 1091a1 <== NOT EXECUTED 109195: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) <== NOT EXECUTED 10919c: 0f 95 c3 setne %bl <== NOT EXECUTED 10919f: eb 02 jmp 1091a3 <== NOT EXECUTED 1091a1: 31 db xor %ebx,%ebx <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 1091a3: e8 00 26 00 00 call 10b7a8 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) 1091a8: 31 d2 xor %edx,%edx <== NOT EXECUTED 1091aa: 84 db test %bl,%bl <== NOT EXECUTED 1091ac: 74 1b je 1091c9 <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 1091ae: 50 push %eax <== NOT EXECUTED 1091af: 50 push %eax <== NOT EXECUTED 1091b0: 6a ff push $0xffffffff <== NOT EXECUTED 1091b2: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED 1091b8: e8 7f fb ff ff call 108d3c <_POSIX_Thread_Exit> <== NOT EXECUTED 1091bd: 31 d2 xor %edx,%edx <== NOT EXECUTED 1091bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1091c2: eb 05 jmp 1091c9 <== NOT EXECUTED 1091c4: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED return 0; } 1091c9: 89 d0 mov %edx,%eax <== NOT EXECUTED 1091cb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1091ce: c9 leave <== NOT EXECUTED 1091cf: c3 ret <== NOT EXECUTED 001091d0 : int pthread_setcanceltype( int type, int *oldtype ) { 1091d0: 55 push %ebp <== NOT EXECUTED 1091d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1091d3: 53 push %ebx <== NOT EXECUTED 1091d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1091d7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1091da: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 1091dd: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 1091e2: ba 47 00 00 00 mov $0x47,%edx <== NOT EXECUTED 1091e7: 85 c0 test %eax,%eax <== NOT EXECUTED 1091e9: 75 6d jne 109258 <== NOT EXECUTED return EPROTO; if ( !oldtype ) 1091eb: 85 db test %ebx,%ebx <== NOT EXECUTED 1091ed: 74 64 je 109253 <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 1091ef: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 1091f2: 77 5f ja 109253 <== NOT EXECUTED return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 1091f4: a1 a8 f5 11 00 mov 0x11f5a8,%eax <== NOT EXECUTED 1091f9: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 1091ff: a1 e8 f4 11 00 mov 0x11f4e8,%eax <== NOT EXECUTED 109204: 40 inc %eax <== NOT EXECUTED 109205: a3 e8 f4 11 00 mov %eax,0x11f4e8 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10920a: 8b 82 d0 00 00 00 mov 0xd0(%edx),%eax <== NOT EXECUTED 109210: 89 03 mov %eax,(%ebx) <== NOT EXECUTED thread_support->cancelability_type = type; 109212: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 109218: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx) <== NOT EXECUTED 10921f: 75 0f jne 109230 <== NOT EXECUTED 109221: 49 dec %ecx <== NOT EXECUTED 109222: 75 0c jne 109230 <== NOT EXECUTED 109224: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) <== NOT EXECUTED 10922b: 0f 95 c3 setne %bl <== NOT EXECUTED 10922e: eb 02 jmp 109232 <== NOT EXECUTED 109230: 31 db xor %ebx,%ebx <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 109232: e8 71 25 00 00 call 10b7a8 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) 109237: 31 d2 xor %edx,%edx <== NOT EXECUTED 109239: 84 db test %bl,%bl <== NOT EXECUTED 10923b: 74 1b je 109258 <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10923d: 50 push %eax <== NOT EXECUTED 10923e: 50 push %eax <== NOT EXECUTED 10923f: 6a ff push $0xffffffff <== NOT EXECUTED 109241: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED 109247: e8 f0 fa ff ff call 108d3c <_POSIX_Thread_Exit> <== NOT EXECUTED 10924c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10924e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109251: eb 05 jmp 109258 <== NOT EXECUTED 109253: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED return 0; } 109258: 89 d0 mov %edx,%eax <== NOT EXECUTED 10925a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10925d: c9 leave <== NOT EXECUTED 10925e: c3 ret <== NOT EXECUTED 0010b28c : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10b28c: 55 push %ebp <== NOT EXECUTED 10b28d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b28f: 57 push %edi <== NOT EXECUTED 10b290: 56 push %esi <== NOT EXECUTED 10b291: 53 push %ebx <== NOT EXECUTED 10b292: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Check all the parameters */ if ( !param ) 10b295: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10b299: 0f 84 7e 01 00 00 je 10b41d <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10b29f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b2a2: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10b2a4: 48 dec %eax <== NOT EXECUTED 10b2a5: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10b2aa: 0f 87 6d 01 00 00 ja 10b41d <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10b2b0: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10b2b4: 74 1f je 10b2d5 <== NOT EXECUTED 10b2b6: 7f 0b jg 10b2c3 <== NOT EXECUTED 10b2b8: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10b2bc: 74 20 je 10b2de <== NOT EXECUTED 10b2be: e9 5a 01 00 00 jmp 10b41d <== NOT EXECUTED 10b2c3: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10b2c7: 74 25 je 10b2ee <== NOT EXECUTED 10b2c9: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10b2cd: 0f 85 4a 01 00 00 jne 10b41d <== NOT EXECUTED 10b2d3: eb 22 jmp 10b2f7 <== NOT EXECUTED 10b2d5: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 10b2dc: eb 07 jmp 10b2e5 <== NOT EXECUTED 10b2de: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED 10b2e5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10b2ec: eb 53 jmp 10b341 <== NOT EXECUTED 10b2ee: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED 10b2f5: eb ee jmp 10b2e5 <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < 10b2f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b2fa: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b2fd: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10b300: 50 push %eax <== NOT EXECUTED 10b301: e8 d2 31 00 00 call 10e4d8 <_Timespec_To_ticks> <== NOT EXECUTED 10b306: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10b308: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b30b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10b30e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10b311: e8 c2 31 00 00 call 10e4d8 <_Timespec_To_ticks> <== NOT EXECUTED 10b316: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b319: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b31b: 0f 82 fc 00 00 00 jb 10b41d <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 10b321: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b324: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10b327: 48 dec %eax <== NOT EXECUTED 10b328: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10b32d: 0f 87 ea 00 00 00 ja 10b41d <== NOT EXECUTED 10b333: c7 45 dc 03 00 00 00 movl $0x3,-0x24(%ebp) <== NOT EXECUTED 10b33a: c7 45 e0 b4 b1 10 00 movl $0x10b1b4,-0x20(%ebp) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10b341: 53 push %ebx <== NOT EXECUTED 10b342: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b345: 50 push %eax <== NOT EXECUTED 10b346: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b349: 68 b8 2c 12 00 push $0x122cb8 <== NOT EXECUTED 10b34e: e8 e9 1d 00 00 call 10d13c <_Objects_Get> <== NOT EXECUTED 10b353: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10b356: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b359: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10b35e: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10b362: 0f 85 ba 00 00 00 jne 10b422 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10b368: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10b36b: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) 10b371: 83 7b 7c 03 cmpl $0x3,0x7c(%ebx) <== NOT EXECUTED 10b375: 75 12 jne 10b389 <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); 10b377: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b37a: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10b380: 50 push %eax <== NOT EXECUTED 10b381: e8 72 35 00 00 call 10e8f8 <_Watchdog_Remove> <== NOT EXECUTED 10b386: 83 c4 10 add $0x10,%esp <== NOT EXECUTED api->schedpolicy = policy; 10b389: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b38c: 89 53 7c mov %edx,0x7c(%ebx) <== NOT EXECUTED api->schedparam = *param; 10b38f: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10b395: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10b39a: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b39d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_thread->budget_algorithm = budget_algorithm; 10b39f: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b3a2: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10b3a5: 89 50 7c mov %edx,0x7c(%eax) <== NOT EXECUTED the_thread->budget_callout = budget_callout; 10b3a8: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10b3ab: 89 b0 80 00 00 00 mov %esi,0x80(%eax) <== NOT EXECUTED switch ( api->schedpolicy ) { 10b3b1: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10b3b5: 78 5d js 10b414 <== NOT EXECUTED 10b3b7: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10b3bb: 7e 08 jle 10b3c5 <== NOT EXECUTED 10b3bd: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10b3c1: 75 51 jne 10b414 <== NOT EXECUTED 10b3c3: eb 25 jmp 10b3ea <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b3c5: a1 14 2a 12 00 mov 0x122a14,%eax <== NOT EXECUTED 10b3ca: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10b3cd: 89 42 78 mov %eax,0x78(%edx) <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10b3d0: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10b3d5: 2b 83 80 00 00 00 sub 0x80(%ebx),%eax <== NOT EXECUTED the_thread->real_priority = 10b3db: 89 42 18 mov %eax,0x18(%edx) <== NOT EXECUTED _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10b3de: 51 push %ecx <== NOT EXECUTED 10b3df: 6a 01 push $0x1 <== NOT EXECUTED 10b3e1: 50 push %eax <== NOT EXECUTED 10b3e2: 52 push %edx <== NOT EXECUTED 10b3e3: e8 74 20 00 00 call 10d45c <_Thread_Change_priority> <== NOT EXECUTED 10b3e8: eb 27 jmp 10b411 <== NOT EXECUTED TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10b3ea: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10b3f0: 89 83 98 00 00 00 mov %eax,0x98(%ebx) <== NOT EXECUTED _Watchdog_Remove( &api->Sporadic_timer ); 10b3f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3f9: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10b3ff: 50 push %eax <== NOT EXECUTED 10b400: e8 f3 34 00 00 call 10e8f8 <_Watchdog_Remove> <== NOT EXECUTED _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10b405: 58 pop %eax <== NOT EXECUTED 10b406: 5a pop %edx <== NOT EXECUTED 10b407: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10b40a: 6a 00 push $0x0 <== NOT EXECUTED 10b40c: e8 e1 fd ff ff call 10b1f2 <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED 10b411: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _Thread_Enable_dispatch(); 10b414: e8 e3 24 00 00 call 10d8fc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b419: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b41b: eb 05 jmp 10b422 <== NOT EXECUTED return 0; 10b41d: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10b422: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b425: 5b pop %ebx <== NOT EXECUTED 10b426: 5e pop %esi <== NOT EXECUTED 10b427: 5f pop %edi <== NOT EXECUTED 10b428: c9 leave <== NOT EXECUTED 10b429: c3 ret <== NOT EXECUTED 00109094 : int pthread_setspecific( pthread_key_t key, const void *value ) { 109094: 55 push %ebp <== NOT EXECUTED 109095: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109097: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10909a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10909d: 50 push %eax <== NOT EXECUTED 10909e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1090a1: 68 9c 03 12 00 push $0x12039c <== NOT EXECUTED 1090a6: e8 d1 23 00 00 call 10b47c <_Objects_Get> <== NOT EXECUTED 1090ab: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 1090ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090b0: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 1090b5: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 1090b9: 75 27 jne 1090e2 <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 1090bb: a1 28 00 12 00 mov 0x120028,%eax <== NOT EXECUTED 1090c0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 1090c3: 89 d0 mov %edx,%eax <== NOT EXECUTED 1090c5: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 1090c8: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 1090cb: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 1090d1: 8b 4c 81 18 mov 0x18(%ecx,%eax,4),%ecx <== NOT EXECUTED 1090d5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1090d8: 89 04 91 mov %eax,(%ecx,%edx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 1090db: e8 5c 2b 00 00 call 10bc3c <_Thread_Enable_dispatch> <== NOT EXECUTED 1090e0: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 1090e2: c9 leave <== NOT EXECUTED 1090e3: c3 ret <== NOT EXECUTED 0010e838 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 10e838: 55 push %ebp <== NOT EXECUTED 10e839: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e83b: 57 push %edi <== NOT EXECUTED 10e83c: 56 push %esi <== NOT EXECUTED 10e83d: 53 push %ebx <== NOT EXECUTED 10e83e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e841: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10e844: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e847: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED POSIX_API_Control *api; if ( !set && !oset ) 10e84a: 85 db test %ebx,%ebx <== NOT EXECUTED 10e84c: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10e850: 75 04 jne 10e856 <== NOT EXECUTED 10e852: 85 d2 test %edx,%edx <== NOT EXECUTED 10e854: 74 4e je 10e8a4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10e856: 8b 3d 98 00 12 00 mov 0x120098,%edi <== NOT EXECUTED 10e85c: 8b 8f f8 00 00 00 mov 0xf8(%edi),%ecx <== NOT EXECUTED if ( oset ) 10e862: 85 d2 test %edx,%edx <== NOT EXECUTED 10e864: 74 08 je 10e86e <== NOT EXECUTED *oset = api->signals_blocked; 10e866: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 10e86c: 89 02 mov %eax,(%edx) <== NOT EXECUTED if ( !set ) 10e86e: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10e872: 75 61 jne 10e8d5 <== NOT EXECUTED return 0; switch ( how ) { 10e874: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10e877: 74 0b je 10e884 <== NOT EXECUTED 10e879: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10e87c: 74 10 je 10e88e <== NOT EXECUTED 10e87e: 85 f6 test %esi,%esi <== NOT EXECUTED 10e880: 74 18 je 10e89a <== NOT EXECUTED 10e882: eb 20 jmp 10e8a4 <== NOT EXECUTED case SIG_BLOCK: api->signals_blocked |= *set; 10e884: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e886: 09 81 c4 00 00 00 or %eax,0xc4(%ecx) <== NOT EXECUTED 10e88c: eb 26 jmp 10e8b4 <== NOT EXECUTED break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 10e88e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e890: f7 d0 not %eax <== NOT EXECUTED 10e892: 21 81 c4 00 00 00 and %eax,0xc4(%ecx) <== NOT EXECUTED 10e898: eb 1a jmp 10e8b4 <== NOT EXECUTED break; case SIG_SETMASK: api->signals_blocked = *set; 10e89a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e89c: 89 81 c4 00 00 00 mov %eax,0xc4(%ecx) <== NOT EXECUTED 10e8a2: eb 10 jmp 10e8b4 <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10e8a4: e8 07 16 00 00 call 10feb0 <__errno> <== NOT EXECUTED 10e8a9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e8af: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10e8b2: eb 23 jmp 10e8d7 <== NOT EXECUTED /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 10e8b4: 8b 15 48 07 12 00 mov 0x120748,%edx <== NOT EXECUTED 10e8ba: 0b 91 c8 00 00 00 or 0xc8(%ecx),%edx <== NOT EXECUTED 10e8c0: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 10e8c6: f7 d0 not %eax <== NOT EXECUTED 10e8c8: 85 c2 test %eax,%edx <== NOT EXECUTED 10e8ca: 74 09 je 10e8d5 <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; 10e8cc: c6 47 75 01 movb $0x1,0x75(%edi) <== NOT EXECUTED _Thread_Dispatch(); 10e8d0: e8 a3 d2 ff ff call 10bb78 <_Thread_Dispatch> <== NOT EXECUTED 10e8d5: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 10e8d7: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e8da: 5b pop %ebx <== NOT EXECUTED 10e8db: 5e pop %esi <== NOT EXECUTED 10e8dc: 5f pop %edi <== NOT EXECUTED 10e8dd: c9 leave <== NOT EXECUTED 10e8de: c3 ret <== NOT EXECUTED 00108f68 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 108f68: 55 push %ebp <== NOT EXECUTED 108f69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f6b: 53 push %ebx <== NOT EXECUTED 108f6c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 108f6f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 108f72: 85 d2 test %edx,%edx <== NOT EXECUTED 108f74: 74 55 je 108fcb <== 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 108f76: 53 push %ebx <== NOT EXECUTED 108f77: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 108f7a: 50 push %eax <== NOT EXECUTED 108f7b: ff 32 pushl (%edx) <== NOT EXECUTED 108f7d: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 108f82: e8 2d 20 00 00 call 10afb4 <_Objects_Get> <== NOT EXECUTED 108f87: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 108f89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f8c: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 108f90: 75 39 jne 108fcb <== 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. * 108f92: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { 108f95: 85 c0 test %eax,%eax <== NOT EXECUTED 108f97: 74 0c je 108fa5 <== NOT EXECUTED _Thread_Enable_dispatch(); 108f99: e8 d6 27 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED 108f9e: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 108fa3: eb 2b jmp 108fd0 <== NOT EXECUTED return EBUSY; } _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); 108fa5: 51 push %ecx <== NOT EXECUTED 108fa6: 51 push %ecx <== NOT EXECUTED 108fa7: 53 push %ebx <== NOT EXECUTED 108fa8: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 108fad: e8 32 1c 00 00 call 10abe4 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 108fb2: 58 pop %eax <== NOT EXECUTED 108fb3: 5a pop %edx <== NOT EXECUTED 108fb4: 53 push %ebx <== NOT EXECUTED 108fb5: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 108fba: e8 c1 1e 00 00 call 10ae80 <_Objects_Free> <== NOT EXECUTED _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 108fbf: e8 b0 27 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED 108fc4: 31 c0 xor %eax,%eax <== NOT EXECUTED 108fc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fc9: eb 05 jmp 108fd0 <== NOT EXECUTED return 0; 108fcb: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 108fd0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108fd3: c9 leave <== NOT EXECUTED 108fd4: c3 ret <== NOT EXECUTED 00108fd8 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 108fd8: 55 push %ebp <== NOT EXECUTED 108fd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fdb: 56 push %esi <== NOT EXECUTED 108fdc: 53 push %ebx <== NOT EXECUTED 108fdd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108fe0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 108fe3: 85 f6 test %esi,%esi <== NOT EXECUTED 108fe5: 74 65 je 10904c <== NOT EXECUTED return EINVAL; switch ( pshared ) { 108fe7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 108feb: 75 5f jne 10904c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108fed: a1 f8 e5 11 00 mov 0x11e5f8,%eax <== NOT EXECUTED 108ff2: 40 inc %eax <== NOT EXECUTED 108ff3: a3 f8 e5 11 00 mov %eax,0x11e5f8 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 108ff8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ffb: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 109000: e8 6b 1b 00 00 call 10ab70 <_Objects_Allocate> <== NOT EXECUTED 109005: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 109007: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10900a: 85 c0 test %eax,%eax <== NOT EXECUTED 10900c: 75 0c jne 10901a <== NOT EXECUTED _Thread_Enable_dispatch(); 10900e: e8 61 27 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED 109013: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 109018: eb 37 jmp 109051 <== NOT EXECUTED return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 10901a: 50 push %eax <== NOT EXECUTED 10901b: 50 push %eax <== NOT EXECUTED 10901c: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10901f: 50 push %eax <== NOT EXECUTED 109020: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 109023: 50 push %eax <== NOT EXECUTED 109024: e8 d7 16 00 00 call 10a700 <_CORE_spinlock_Initialize> <== NOT EXECUTED 109029: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10902c: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10902f: a1 c4 e8 11 00 mov 0x11e8c4,%eax <== NOT EXECUTED 109034: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109037: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 10903e: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 109040: e8 2f 27 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED 109045: 31 c0 xor %eax,%eax <== NOT EXECUTED 109047: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10904a: eb 05 jmp 109051 <== NOT EXECUTED return 0; 10904c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109051: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109054: 5b pop %ebx <== NOT EXECUTED 109055: 5e pop %esi <== NOT EXECUTED 109056: c9 leave <== NOT EXECUTED 109057: c3 ret <== NOT EXECUTED 00109058 : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 109058: 55 push %ebp <== NOT EXECUTED 109059: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10905b: 53 push %ebx <== NOT EXECUTED 10905c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10905f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 109062: 85 d2 test %edx,%edx <== NOT EXECUTED 109064: 74 3c je 1090a2 <== 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 109066: 51 push %ecx <== NOT EXECUTED 109067: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10906a: 50 push %eax <== NOT EXECUTED 10906b: ff 32 pushl (%edx) <== NOT EXECUTED 10906d: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 109072: e8 3d 1f 00 00 call 10afb4 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 109077: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10907a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10907e: 75 22 jne 1090a2 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 109080: 52 push %edx <== NOT EXECUTED 109081: 6a 00 push $0x0 <== NOT EXECUTED 109083: 6a 01 push $0x1 <== NOT EXECUTED 109085: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 109088: 50 push %eax <== NOT EXECUTED 109089: e8 e2 16 00 00 call 10a770 <_CORE_spinlock_Wait> <== NOT EXECUTED 10908e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 109090: e8 df 26 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 109095: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109098: e8 0f 00 00 00 call 1090ac <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10909d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090a0: eb 05 jmp 1090a7 <== NOT EXECUTED 1090a2: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 1090a7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1090aa: c9 leave <== NOT EXECUTED 1090ab: c3 ret <== NOT EXECUTED 001090bc : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 1090bc: 55 push %ebp <== NOT EXECUTED 1090bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090bf: 53 push %ebx <== NOT EXECUTED 1090c0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1090c3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 1090c6: 85 d2 test %edx,%edx <== NOT EXECUTED 1090c8: 74 3c je 109106 <== NOT EXECUTED 1090ca: 51 push %ecx <== NOT EXECUTED 1090cb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1090ce: 50 push %eax <== NOT EXECUTED 1090cf: ff 32 pushl (%edx) <== NOT EXECUTED 1090d1: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 1090d6: e8 d9 1e 00 00 call 10afb4 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 1090db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090de: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1090e2: 75 22 jne 109106 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 1090e4: 52 push %edx <== NOT EXECUTED 1090e5: 6a 00 push $0x0 <== NOT EXECUTED 1090e7: 6a 00 push $0x0 <== NOT EXECUTED 1090e9: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1090ec: 50 push %eax <== NOT EXECUTED 1090ed: e8 7e 16 00 00 call 10a770 <_CORE_spinlock_Wait> <== NOT EXECUTED 1090f2: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 1090f4: e8 7b 26 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 1090f9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1090fc: e8 ab ff ff ff call 1090ac <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 109101: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109104: eb 05 jmp 10910b <== NOT EXECUTED 109106: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10910b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10910e: c9 leave <== NOT EXECUTED 10910f: c3 ret <== NOT EXECUTED 00109110 : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 109110: 55 push %ebp <== NOT EXECUTED 109111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109113: 53 push %ebx <== NOT EXECUTED 109114: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109117: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10911a: 85 d2 test %edx,%edx <== NOT EXECUTED 10911c: 74 3a je 109158 <== NOT EXECUTED 10911e: 50 push %eax <== NOT EXECUTED 10911f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109122: 50 push %eax <== NOT EXECUTED 109123: ff 32 pushl (%edx) <== NOT EXECUTED 109125: 68 a8 e8 11 00 push $0x11e8a8 <== NOT EXECUTED 10912a: e8 85 1e 00 00 call 10afb4 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10912f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109132: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109136: 75 20 jne 109158 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 109138: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10913b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10913e: 50 push %eax <== NOT EXECUTED 10913f: e8 e0 15 00 00 call 10a724 <_CORE_spinlock_Release> <== NOT EXECUTED 109144: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 109146: e8 29 26 00 00 call 10b774 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10914b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10914e: e8 59 ff ff ff call 1090ac <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 109153: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109156: eb 05 jmp 10915d <== NOT EXECUTED 109158: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10915d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109160: c9 leave <== NOT EXECUTED 109161: c3 ret <== NOT EXECUTED 00109288 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 109288: 55 push %ebp <== NOT EXECUTED 109289: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10928b: 53 push %ebx <== NOT EXECUTED 10928c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10928f: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 109294: 85 c0 test %eax,%eax <== NOT EXECUTED 109296: 75 46 jne 1092de <== NOT EXECUTED return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109298: a1 a8 f5 11 00 mov 0x11f5a8,%eax <== NOT EXECUTED 10929d: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 1092a3: a1 e8 f4 11 00 mov 0x11f4e8,%eax <== NOT EXECUTED 1092a8: 40 inc %eax <== NOT EXECUTED 1092a9: a3 e8 f4 11 00 mov %eax,0x11f4e8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 1092ae: 31 db xor %ebx,%ebx <== NOT EXECUTED 1092b0: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx) <== NOT EXECUTED 1092b7: 75 0a jne 1092c3 <== NOT EXECUTED 1092b9: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) <== NOT EXECUTED 1092c0: 0f 95 c3 setne %bl <== NOT EXECUTED thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 1092c3: e8 e0 24 00 00 call 10b7a8 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) 1092c8: 84 db test %bl,%bl <== NOT EXECUTED 1092ca: 74 12 je 1092de <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 1092cc: 50 push %eax <== NOT EXECUTED 1092cd: 50 push %eax <== NOT EXECUTED 1092ce: 6a ff push $0xffffffff <== NOT EXECUTED 1092d0: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED 1092d6: e8 61 fa ff ff call 108d3c <_POSIX_Thread_Exit> <== NOT EXECUTED 1092db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1092de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1092e1: c9 leave <== NOT EXECUTED 1092e2: c3 ret <== NOT EXECUTED 001156ec : ssize_t read( int fd, void *buffer, size_t count ) { 1156ec: 55 push %ebp <== NOT EXECUTED 1156ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1156ef: 56 push %esi <== NOT EXECUTED 1156f0: 53 push %ebx <== NOT EXECUTED 1156f1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1156f4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1156f7: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1156fa: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 115700: 73 11 jae 115713 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 115702: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 115705: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 11570b: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 11570e: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 115711: 75 0d jne 115720 <== NOT EXECUTED 115713: e8 a0 99 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 115718: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11571e: eb 31 jmp 115751 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 115720: 85 f6 test %esi,%esi <== NOT EXECUTED 115722: 74 0b je 11572f <== NOT EXECUTED rtems_libio_check_count( count ); 115724: 31 c0 xor %eax,%eax <== NOT EXECUTED 115726: 85 c9 test %ecx,%ecx <== NOT EXECUTED 115728: 74 3c je 115766 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11572a: 80 e2 02 and $0x2,%dl <== NOT EXECUTED 11572d: 75 0d jne 11573c <== NOT EXECUTED 11572f: e8 84 99 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 115734: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11573a: eb 15 jmp 115751 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 11573c: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 11573f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 115742: 85 c0 test %eax,%eax <== NOT EXECUTED 115744: 75 10 jne 115756 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 115746: e8 6d 99 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 11574b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 115751: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 115754: eb 10 jmp 115766 <== NOT EXECUTED rc = (*iop->handlers->read_h)( iop, buffer, count ); 115756: 52 push %edx <== NOT EXECUTED 115757: 51 push %ecx <== NOT EXECUTED 115758: 56 push %esi <== NOT EXECUTED 115759: 53 push %ebx <== NOT EXECUTED 11575a: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 11575c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11575f: 85 c0 test %eax,%eax <== NOT EXECUTED 115761: 7e 03 jle 115766 <== NOT EXECUTED iop->offset += rc; 115763: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 115766: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 115769: 5b pop %ebx <== NOT EXECUTED 11576a: 5e pop %esi <== NOT EXECUTED 11576b: c9 leave <== NOT EXECUTED 11576c: c3 ret <== NOT EXECUTED 001205b4 : /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) { 1205b4: 55 push %ebp <== NOT EXECUTED 1205b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1205b7: 56 push %esi <== NOT EXECUTED 1205b8: 53 push %ebx <== NOT EXECUTED 1205b9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED register struct dirent *dp; if ( !dirp ) 1205bc: 85 db test %ebx,%ebx <== NOT EXECUTED 1205be: 74 5b je 12061b <== NOT EXECUTED return NULL; for (;;) { if (dirp->dd_loc == 0) { 1205c0: 83 7b 04 00 cmpl $0x0,0x4(%ebx) <== NOT EXECUTED 1205c4: 75 18 jne 1205de <== NOT EXECUTED dirp->dd_size = getdents (dirp->dd_fd, 1205c6: 50 push %eax <== NOT EXECUTED 1205c7: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1205ca: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1205cd: ff 33 pushl (%ebx) <== NOT EXECUTED 1205cf: e8 dc 94 00 00 call 129ab0 <== NOT EXECUTED 1205d4: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 1205d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1205da: 85 c0 test %eax,%eax <== NOT EXECUTED 1205dc: 7e 3d jle 12061b <== NOT EXECUTED return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 1205de: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 1205e1: 3b 4b 08 cmp 0x8(%ebx),%ecx <== NOT EXECUTED 1205e4: 7c 09 jl 1205ef <== NOT EXECUTED dirp->dd_loc = 0; 1205e6: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED 1205ed: eb d1 jmp 1205c0 <== NOT EXECUTED continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 1205ef: 89 ca mov %ecx,%edx <== NOT EXECUTED 1205f1: 03 53 0c add 0xc(%ebx),%edx <== NOT EXECUTED if ((intptr_t)dp & 03) /* bogus pointer check */ 1205f4: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 1205f7: 75 22 jne 12061b <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 1205f9: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 1205fc: 66 85 c0 test %ax,%ax <== NOT EXECUTED 1205ff: 74 1a je 12061b <== NOT EXECUTED 120601: 0f b7 f0 movzwl %ax,%esi <== NOT EXECUTED 120604: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120607: 40 inc %eax <== NOT EXECUTED 120608: 29 c8 sub %ecx,%eax <== NOT EXECUTED 12060a: 39 c6 cmp %eax,%esi <== NOT EXECUTED 12060c: 7f 0d jg 12061b <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 12060e: 8d 04 0e lea (%esi,%ecx,1),%eax <== NOT EXECUTED 120611: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (dp->d_ino == 0) 120614: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 120617: 74 a7 je 1205c0 <== NOT EXECUTED 120619: eb 02 jmp 12061d <== NOT EXECUTED 12061b: 31 d2 xor %edx,%edx <== NOT EXECUTED continue; return (dp); } } 12061d: 89 d0 mov %edx,%eax <== NOT EXECUTED 12061f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120622: 5b pop %ebx <== NOT EXECUTED 120623: 5e pop %esi <== NOT EXECUTED 120624: c9 leave <== NOT EXECUTED 120625: c3 ret <== NOT EXECUTED 00120628 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 120628: 55 push %ebp <== NOT EXECUTED 120629: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12062b: 57 push %edi <== NOT EXECUTED 12062c: 56 push %esi <== NOT EXECUTED 12062d: 53 push %ebx <== NOT EXECUTED 12062e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 120631: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if (!buf) 120634: 85 ff test %edi,%edi <== NOT EXECUTED 120636: 75 0d jne 120645 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 120638: e8 0f ae 00 00 call 12b44c <__errno> <== NOT EXECUTED 12063d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 120643: eb 43 jmp 120688 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 120645: 6a 00 push $0x0 <== NOT EXECUTED 120647: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 12064a: 56 push %esi <== NOT EXECUTED 12064b: 6a 00 push $0x0 <== NOT EXECUTED 12064d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120650: e8 a5 98 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 120655: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120658: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 12065b: 85 c0 test %eax,%eax <== NOT EXECUTED 12065d: 0f 85 87 00 00 00 jne 1206ea <== NOT EXECUTED return -1; if ( !loc.ops->node_type_h ){ 120663: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120666: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 120669: 85 d2 test %edx,%edx <== NOT EXECUTED 12066b: 75 20 jne 12068d <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12066d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120670: 85 c0 test %eax,%eax <== NOT EXECUTED 120672: 74 09 je 12067d <== NOT EXECUTED 120674: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120677: 56 push %esi <== NOT EXECUTED 120678: ff d0 call *%eax <== NOT EXECUTED 12067a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12067d: e8 ca ad 00 00 call 12b44c <__errno> <== NOT EXECUTED 120682: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120688: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 12068b: eb 5d jmp 1206ea <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 12068d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120690: 56 push %esi <== NOT EXECUTED 120691: ff d2 call *%edx <== NOT EXECUTED 120693: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120696: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 120699: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12069c: 74 21 je 1206bf <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12069e: 85 c0 test %eax,%eax <== NOT EXECUTED 1206a0: 74 10 je 1206b2 <== NOT EXECUTED 1206a2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1206a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1206a7: 74 09 je 1206b2 <== NOT EXECUTED 1206a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1206ac: 56 push %esi <== NOT EXECUTED 1206ad: ff d0 call *%eax <== NOT EXECUTED 1206af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 1206b2: e8 95 ad 00 00 call 12b44c <__errno> <== NOT EXECUTED 1206b7: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1206bd: eb c9 jmp 120688 <== NOT EXECUTED } if ( !loc.ops->readlink_h ){ 1206bf: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 1206c2: 85 d2 test %edx,%edx <== NOT EXECUTED 1206c4: 74 a7 je 12066d <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 1206c6: 50 push %eax <== NOT EXECUTED 1206c7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1206ca: 57 push %edi <== NOT EXECUTED 1206cb: 56 push %esi <== NOT EXECUTED 1206cc: ff d2 call *%edx <== NOT EXECUTED 1206ce: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1206d0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1206d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1206d6: 85 c0 test %eax,%eax <== NOT EXECUTED 1206d8: 74 10 je 1206ea <== NOT EXECUTED 1206da: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1206dd: 85 c0 test %eax,%eax <== NOT EXECUTED 1206df: 74 09 je 1206ea <== NOT EXECUTED 1206e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1206e4: 56 push %esi <== NOT EXECUTED 1206e5: ff d0 call *%eax <== NOT EXECUTED 1206e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1206ea: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1206ec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1206ef: 5b pop %ebx <== NOT EXECUTED 1206f0: 5e pop %esi <== NOT EXECUTED 1206f1: 5f pop %edi <== NOT EXECUTED 1206f2: c9 leave <== NOT EXECUTED 1206f3: c3 ret <== NOT EXECUTED 001157ec : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 1157ec: 55 push %ebp <== NOT EXECUTED 1157ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1157ef: 57 push %edi <== NOT EXECUTED 1157f0: 56 push %esi <== NOT EXECUTED 1157f1: 53 push %ebx <== NOT EXECUTED 1157f2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1157f5: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1157f8: ff 05 98 d5 11 00 incl 0x11d598 <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 1157fe: 83 3d 18 d8 11 00 03 cmpl $0x3,0x11d818 <== NOT EXECUTED 115805: 75 1a jne 115821 <== NOT EXECUTED if (_Thread_Dispatch_disable_level > 0) 115807: a1 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 11580c: 85 c0 test %eax,%eax <== NOT EXECUTED 11580e: 0f 85 b7 00 00 00 jne 1158cb <== NOT EXECUTED return (void *) 0; if (_ISR_Nest_level > 0) 115814: a1 14 d7 11 00 mov 0x11d714,%eax <== NOT EXECUTED 115819: 85 c0 test %eax,%eax <== NOT EXECUTED 11581b: 0f 85 aa 00 00 00 jne 1158cb <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 115821: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 115825: 75 0e jne 115835 <== NOT EXECUTED return malloc( size ); 115827: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11582a: 53 push %ebx <== NOT EXECUTED 11582b: e8 34 0e ff ff call 106664 <== NOT EXECUTED 115830: e9 8e 00 00 00 jmp 1158c3 <== NOT EXECUTED if ( !size ) { 115835: 85 db test %ebx,%ebx <== NOT EXECUTED 115837: 75 14 jne 11584d <== NOT EXECUTED free( ptr ); 115839: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11583c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11583f: e8 24 0c ff ff call 106468 <== NOT EXECUTED 115844: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 11584b: eb 79 jmp 1158c6 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 11584d: 52 push %edx <== NOT EXECUTED 11584e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 115851: 50 push %eax <== NOT EXECUTED 115852: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115855: 68 30 d5 11 00 push $0x11d530 <== NOT EXECUTED 11585a: e8 05 01 00 00 call 115964 <_Protected_heap_Get_block_size> <== NOT EXECUTED 11585f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115862: 84 c0 test %al,%al <== NOT EXECUTED 115864: 75 0d jne 115873 <== NOT EXECUTED errno = EINVAL; 115866: e8 4d 98 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 11586b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 115871: eb 58 jmp 1158cb <== 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 ) ) { 115873: 50 push %eax <== NOT EXECUTED 115874: 53 push %ebx <== NOT EXECUTED 115875: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115878: 68 30 d5 11 00 push $0x11d530 <== NOT EXECUTED 11587d: e8 1a 01 00 00 call 11599c <_Protected_heap_Resize_block> <== NOT EXECUTED 115882: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115885: 84 c0 test %al,%al <== NOT EXECUTED 115887: 75 49 jne 1158d2 <== 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 ); 115889: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11588c: 53 push %ebx <== NOT EXECUTED 11588d: e8 d2 0d ff ff call 106664 <== NOT EXECUTED 115892: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 115895: ff 0d 8c d5 11 00 decl 0x11d58c <== NOT EXECUTED if ( !new_area ) { 11589b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11589e: 85 c0 test %eax,%eax <== NOT EXECUTED 1158a0: 74 29 je 1158cb <== NOT EXECUTED return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 1158a2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1158a5: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1158a7: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 1158a9: 76 02 jbe 1158ad <== NOT EXECUTED 1158ab: 89 c1 mov %eax,%ecx <== NOT EXECUTED 1158ad: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 1158b0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1158b3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED free( ptr ); 1158b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158b8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1158bb: e8 a8 0b ff ff call 106468 <== NOT EXECUTED 1158c0: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 1158c3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1158c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158c9: eb 07 jmp 1158d2 <== NOT EXECUTED return new_area; 1158cb: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED } 1158d2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1158d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1158d8: 5b pop %ebx <== NOT EXECUTED 1158d9: 5e pop %esi <== NOT EXECUTED 1158da: 5f pop %edi <== NOT EXECUTED 1158db: c9 leave <== NOT EXECUTED 1158dc: c3 ret <== NOT EXECUTED 00108cdc : #include void rewinddir( DIR *dirp ) { 108cdc: 55 push %ebp <== NOT EXECUTED 108cdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108cdf: 53 push %ebx <== NOT EXECUTED 108ce0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 108ce3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED off_t status; if ( !dirp ) 108ce6: 85 db test %ebx,%ebx <== NOT EXECUTED 108ce8: 74 19 je 108d03 <== NOT EXECUTED return; status = lseek( dirp->dd_fd, 0, SEEK_SET ); 108cea: 50 push %eax <== NOT EXECUTED 108ceb: 6a 00 push $0x0 <== NOT EXECUTED 108ced: 6a 00 push $0x0 <== NOT EXECUTED 108cef: ff 33 pushl (%ebx) <== NOT EXECUTED 108cf1: e8 d6 f0 ff ff call 107dcc <== NOT EXECUTED if( status == -1 ) 108cf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108cf9: 40 inc %eax <== NOT EXECUTED 108cfa: 74 07 je 108d03 <== NOT EXECUTED return; dirp->dd_loc = 0; 108cfc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED } 108d03: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108d06: c9 leave <== NOT EXECUTED 108d07: c3 ret <== NOT EXECUTED 001206f4 : #include int rmdir( const char *pathname ) { 1206f4: 55 push %ebp <== NOT EXECUTED 1206f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1206f7: 56 push %esi <== NOT EXECUTED 1206f8: 53 push %ebx <== NOT EXECUTED 1206f9: 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 ); 1206fc: 6a 00 push $0x0 <== NOT EXECUTED 1206fe: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 120701: 56 push %esi <== NOT EXECUTED 120702: 6a 00 push $0x0 <== NOT EXECUTED 120704: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120707: e8 ee 97 fe ff call 109efa <== NOT EXECUTED if ( result != 0 ) 12070c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12070f: 85 c0 test %eax,%eax <== NOT EXECUTED 120711: 0f 85 be 00 00 00 jne 1207d5 <== NOT EXECUTED return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 120717: 50 push %eax <== NOT EXECUTED 120718: 50 push %eax <== NOT EXECUTED 120719: 56 push %esi <== NOT EXECUTED 12071a: 6a 02 push $0x2 <== NOT EXECUTED 12071c: e8 63 97 fe ff call 109e84 <== NOT EXECUTED if (result != 0) { 120721: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120724: 85 c0 test %eax,%eax <== NOT EXECUTED 120726: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120729: 74 21 je 12074c <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12072b: 85 c0 test %eax,%eax <== NOT EXECUTED 12072d: 0f 84 a2 00 00 00 je 1207d5 <== NOT EXECUTED 120733: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120736: 85 c0 test %eax,%eax <== NOT EXECUTED 120738: 0f 84 97 00 00 00 je 1207d5 <== NOT EXECUTED 12073e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120741: 56 push %esi <== NOT EXECUTED 120742: ff d0 call *%eax <== NOT EXECUTED 120744: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 120747: e9 84 00 00 00 jmp 1207d0 <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 12074c: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 12074f: 85 d2 test %edx,%edx <== NOT EXECUTED 120751: 74 41 je 120794 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 120753: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120756: 56 push %esi <== NOT EXECUTED 120757: ff d2 call *%edx <== NOT EXECUTED 120759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12075c: 48 dec %eax <== NOT EXECUTED 12075d: 74 24 je 120783 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12075f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120762: 85 c0 test %eax,%eax <== NOT EXECUTED 120764: 74 10 je 120776 <== NOT EXECUTED 120766: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120769: 85 c0 test %eax,%eax <== NOT EXECUTED 12076b: 74 09 je 120776 <== NOT EXECUTED 12076d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120770: 56 push %esi <== NOT EXECUTED 120771: ff d0 call *%eax <== NOT EXECUTED 120773: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 120776: e8 d1 ac 00 00 call 12b44c <__errno> <== NOT EXECUTED 12077b: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 120781: eb 52 jmp 1207d5 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 120783: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120786: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 120789: 85 c0 test %eax,%eax <== NOT EXECUTED 12078b: 75 24 jne 1207b1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12078d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120790: 85 c0 test %eax,%eax <== NOT EXECUTED 120792: 74 10 je 1207a4 <== NOT EXECUTED 120794: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120797: 85 c0 test %eax,%eax <== NOT EXECUTED 120799: 74 09 je 1207a4 <== NOT EXECUTED 12079b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12079e: 56 push %esi <== NOT EXECUTED 12079f: ff d0 call *%eax <== NOT EXECUTED 1207a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1207a4: e8 a3 ac 00 00 call 12b44c <__errno> <== NOT EXECUTED 1207a9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1207af: eb 24 jmp 1207d5 <== NOT EXECUTED } result = (*loc.handlers->rmnod_h)( &loc ); 1207b1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1207b4: 56 push %esi <== NOT EXECUTED 1207b5: ff d0 call *%eax <== NOT EXECUTED 1207b7: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1207b9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1207bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1207bf: 85 c0 test %eax,%eax <== NOT EXECUTED 1207c1: 74 15 je 1207d8 <== NOT EXECUTED 1207c3: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1207c6: 85 c0 test %eax,%eax <== NOT EXECUTED 1207c8: 74 0e je 1207d8 <== NOT EXECUTED 1207ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1207cd: 56 push %esi <== NOT EXECUTED 1207ce: ff d0 call *%eax <== NOT EXECUTED 1207d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1207d3: eb 03 jmp 1207d8 <== NOT EXECUTED 1207d5: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED return result; } 1207d8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1207da: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1207dd: 5b pop %ebx <== NOT EXECUTED 1207de: 5e pop %esi <== NOT EXECUTED 1207df: c9 leave <== NOT EXECUTED 1207e0: c3 ret <== NOT EXECUTED 0010e8dc : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e8dc: 55 push %ebp <== NOT EXECUTED 10e8dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8df: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10e8e2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e8e5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e8e8: e8 13 00 00 00 call 10e900 <== NOT EXECUTED 10e8ed: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 10e8ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e8f2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e8f4: 85 d2 test %edx,%edx <== NOT EXECUTED 10e8f6: 74 03 je 10e8fb <== NOT EXECUTED return nap->local_value; 10e8f8: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED return 0; } 10e8fb: c9 leave <== NOT EXECUTED 10e8fc: c3 ret <== NOT EXECUTED 0010e8a0 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e8a0: 55 push %ebp <== NOT EXECUTED 10e8a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8a3: 57 push %edi <== NOT EXECUTED 10e8a4: 56 push %esi <== NOT EXECUTED 10e8a5: 53 push %ebx <== NOT EXECUTED 10e8a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e8a9: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e8ae: 31 ff xor %edi,%edi <== NOT EXECUTED 10e8b0: 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) 10e8b2: 85 5d 0c test %ebx,0xc(%ebp) <== NOT EXECUTED 10e8b5: 74 10 je 10e8c7 <== NOT EXECUTED local_value |= rtems_assoc_local_by_remote(ap, b); 10e8b7: 50 push %eax <== NOT EXECUTED 10e8b8: 50 push %eax <== NOT EXECUTED 10e8b9: 53 push %ebx <== NOT EXECUTED 10e8ba: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e8bd: e8 1a 00 00 00 call 10e8dc <== NOT EXECUTED 10e8c2: 09 c7 or %eax,%edi <== NOT EXECUTED 10e8c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10e8c7: d1 e3 shl %ebx <== NOT EXECUTED 10e8c9: 46 inc %esi <== NOT EXECUTED 10e8ca: 83 fe 20 cmp $0x20,%esi <== NOT EXECUTED 10e8cd: 75 e3 jne 10e8b2 <== NOT EXECUTED if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 10e8cf: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e8d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e8d4: 5b pop %ebx <== NOT EXECUTED 10e8d5: 5e pop %esi <== NOT EXECUTED 10e8d6: 5f pop %edi <== NOT EXECUTED 10e8d7: c9 leave <== NOT EXECUTED 10e8d8: c3 ret <== NOT EXECUTED 001152e4 : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 1152e4: 55 push %ebp <== NOT EXECUTED 1152e5: 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; } 1152e7: b8 a8 71 12 00 mov $0x1271a8,%eax <== NOT EXECUTED 1152ec: c9 leave <== NOT EXECUTED 1152ed: c3 ret <== NOT EXECUTED 00111a30 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 111a30: 55 push %ebp <== NOT EXECUTED 111a31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111a33: 53 push %ebx <== NOT EXECUTED 111a34: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111a37: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 111a3a: 53 push %ebx <== NOT EXECUTED 111a3b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111a3e: e8 1d 00 00 00 call 111a60 <== NOT EXECUTED if (nap) 111a43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111a46: 85 c0 test %eax,%eax <== NOT EXECUTED 111a48: 74 07 je 111a51 <== NOT EXECUTED return nap->name; 111a4a: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 111a4c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111a4f: c9 leave <== NOT EXECUTED 111a50: 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); 111a51: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 111a54: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111a57: 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); 111a58: e9 87 38 00 00 jmp 1152e4 <== NOT EXECUTED 0010f034 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10f034: 55 push %ebp <== NOT EXECUTED 10f035: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f037: 56 push %esi <== NOT EXECUTED 10f038: 53 push %ebx <== NOT EXECUTED 10f039: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10f03c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10f03f: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10f041: 85 c0 test %eax,%eax <== NOT EXECUTED 10f043: 74 1b je 10f060 <== NOT EXECUTED 10f045: 52 push %edx <== NOT EXECUTED 10f046: 52 push %edx <== NOT EXECUTED 10f047: 68 f1 79 11 00 push $0x1179f1 <== NOT EXECUTED 10f04c: 50 push %eax <== NOT EXECUTED 10f04d: e8 62 11 00 00 call 1101b4 <== NOT EXECUTED 10f052: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f055: 85 c0 test %eax,%eax <== NOT EXECUTED 10f057: 75 07 jne 10f060 <== NOT EXECUTED default_ap = ap++; 10f059: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f05b: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10f05e: eb 0c jmp 10f06c <== NOT EXECUTED 10f060: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f062: eb 08 jmp 10f06c <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->local_value == local_value) 10f064: 39 73 04 cmp %esi,0x4(%ebx) <== NOT EXECUTED 10f067: 74 0a je 10f073 <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10f069: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10f06c: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10f06f: 75 f3 jne 10f064 <== NOT EXECUTED 10f071: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 10f073: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f075: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f078: 5b pop %ebx <== NOT EXECUTED 10f079: 5e pop %esi <== NOT EXECUTED 10f07a: c9 leave <== NOT EXECUTED 10f07b: c3 ret <== NOT EXECUTED 0010e900 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e900: 55 push %ebp <== NOT EXECUTED 10e901: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e903: 56 push %esi <== NOT EXECUTED 10e904: 53 push %ebx <== NOT EXECUTED 10e905: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e908: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10e90b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e90d: 85 c0 test %eax,%eax <== NOT EXECUTED 10e90f: 74 1b je 10e92c <== NOT EXECUTED 10e911: 52 push %edx <== NOT EXECUTED 10e912: 52 push %edx <== NOT EXECUTED 10e913: 68 f1 79 11 00 push $0x1179f1 <== NOT EXECUTED 10e918: 50 push %eax <== NOT EXECUTED 10e919: e8 96 18 00 00 call 1101b4 <== NOT EXECUTED 10e91e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e921: 85 c0 test %eax,%eax <== NOT EXECUTED 10e923: 75 07 jne 10e92c <== NOT EXECUTED default_ap = ap++; 10e925: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e927: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e92a: eb 0c jmp 10e938 <== NOT EXECUTED 10e92c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e92e: eb 08 jmp 10e938 <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->remote_value == remote_value) 10e930: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10e933: 74 0a je 10e93f <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10e935: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e938: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10e93b: 75 f3 jne 10e930 <== NOT EXECUTED 10e93d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (ap->remote_value == remote_value) return ap; return default_ap; } 10e93f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e941: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e944: 5b pop %ebx <== NOT EXECUTED 10e945: 5e pop %esi <== NOT EXECUTED 10e946: c9 leave <== NOT EXECUTED 10e947: c3 ret <== NOT EXECUTED 0010e948 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10e948: 55 push %ebp <== NOT EXECUTED 10e949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e94b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10e94e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e951: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e954: e8 db 06 00 00 call 10f034 <== NOT EXECUTED 10e959: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 10e95b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e95e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e960: 85 d2 test %edx,%edx <== NOT EXECUTED 10e962: 74 03 je 10e967 <== NOT EXECUTED return nap->remote_value; 10e964: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED return 0; } 10e967: c9 leave <== NOT EXECUTED 10e968: 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 cc 11 12 00 mov 0x1211cc,%eax <== NOT EXECUTED 109593: 40 inc %eax <== NOT EXECUTED 109594: a3 cc 11 12 00 mov %eax,0x1211cc <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109599: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10959c: 68 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 1095a1: e8 62 1b 00 00 call 10b108 <_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 58 27 00 00 call 10bd0c <_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 07 13 00 00 call 10a8d4 <_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 f0 10 12 00 mov 0x1210f0,%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 24 27 00 00 call 10bd0c <_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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 10960b: e8 3c 1f 00 00 call 10b54c <_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 3a 2d 00 00 call 10c368 <_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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 109636: e8 41 1b 00 00 call 10b17c <_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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 109643: e8 d0 1d 00 00 call 10b418 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 109648: e8 bf 26 00 00 call 10bd0c <_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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 10966e: e8 21 20 00 00 call 10b694 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109673: 8b 04 85 64 a2 11 00 mov 0x11a264(,%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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 10969e: e8 a9 1e 00 00 call 10b54c <_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 48 12 00 00 call 10a908 <_CORE_barrier_Release> <== NOT EXECUTED 1096c0: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1096c2: e8 45 26 00 00 call 10bd0c <_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 d4 10 12 00 push $0x1210d4 <== NOT EXECUTED 1096e8: e8 5f 1e 00 00 call 10b54c <_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 27 12 00 00 call 10a938 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 109711: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109714: e8 f3 25 00 00 call 10bd0c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 109719: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10971c: a1 8c 12 12 00 mov 0x12128c,%eax <== NOT EXECUTED 109721: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109724: e8 ef 50 00 00 call 10e818 <_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 71 11 00 jmp *0x1171a4(,%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 8c d6 11 00 00 cmpb $0x0,0x11d68c <== NOT EXECUTED 1089d3: 74 09 je 1089de <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 1089d5: a1 08 d7 11 00 mov 0x11d708,%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 14 d8 11 00 divl 0x11d814 <== 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 c8 d7 11 00 mov 0x11d7c8,%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 8c d6 11 00 00 cmpb $0x0,0x11d68c <== 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 df 14 00 00 call 109f10 <_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 a9 6d 00 00 call 10f800 <== 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 14 d8 11 00 divl 0x11d814 <== 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 8c d6 11 00 00 cmpb $0x0,0x11d68c <== 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 43 14 00 00 call 109f10 <_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 00108cc8 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 108cc8: 55 push %ebp <== NOT EXECUTED 108cc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ccb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108cce: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !uptime ) 108cd1: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108cd6: 85 d2 test %edx,%edx <== NOT EXECUTED 108cd8: 74 0e je 108ce8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 108cda: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108cdd: 52 push %edx <== NOT EXECUTED 108cde: e8 85 15 00 00 call 10a268 <_TOD_Get_uptime> <== NOT EXECUTED 108ce3: 31 c0 xor %eax,%eax <== NOT EXECUTED 108ce5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108ce8: c9 leave <== NOT EXECUTED 108ce9: 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 b0 95 12 00 imul 0x1295b0,%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 14 94 12 00 mov 0x129414,%eax <== NOT EXECUTED 109970: 40 inc %eax <== NOT EXECUTED 109971: a3 14 94 12 00 mov %eax,0x129414 <== 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 13 18 00 00 call 10b194 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 109981: e8 5a 28 00 00 call 10c1e0 <_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 1c d8 11 00 mov %edx,0x11d81c <== 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 89 14 00 00 call 109fa0 <_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 58 d7 11 00 push $0x11d758 <== NOT EXECUTED 108b1f: e8 58 32 00 00 call 10bd7c <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 108b24: e8 9b 2d 00 00 call 10b8c4 <_Thread_Tickle_timeslice> <== NOT EXECUTED 108b29: a0 48 d7 11 00 mov 0x11d748,%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 78 d6 11 00 mov 0x11d678,%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 d9 21 00 00 call 10ad1c <_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 6d 45 00 00 call 10b104 <_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 ac 99 12 00 push $0x1299ac <== NOT EXECUTED 106ba4: e8 eb 63 00 00 call 10cf94 <_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 a0 11 00 push $0x11a076 <== 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 e8 93 12 00 mov 0x1293e8(,%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 a0 11 00 push $0x11a0bb <== 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 d4 94 12 00 mov 0x1294d4,%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 dc 94 12 00 push $0x1294dc <== NOT EXECUTED 106c47: e8 48 63 00 00 call 10cf94 <_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 50 62 00 00 call 10cea8 <_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 68 62 00 00 call 10ced8 <_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 a0 11 00 push $0x11a0ce <== 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 a0 11 00 push $0x11a0e6 <== 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 ac 99 12 00 push $0x1299ac <== NOT EXECUTED 106d17: e8 e8 43 00 00 call 10b104 <_TOD_Get_uptime> <== NOT EXECUTED _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset; 106d1c: a1 ac 99 12 00 mov 0x1299ac,%eax <== NOT EXECUTED 106d21: 8b 15 b0 99 12 00 mov 0x1299b0,%edx <== NOT EXECUTED 106d27: a3 dc 94 12 00 mov %eax,0x1294dc <== NOT EXECUTED 106d2c: 89 15 e0 94 12 00 mov %edx,0x1294e0 <== 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 6e 47 00 00 call 10b4ac <== NOT EXECUTED 106d3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 106d41: c9 leave <== NOT EXECUTED 106d42: c3 ret <== NOT EXECUTED 0010dc71 : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10dc71: 55 push %ebp <== NOT EXECUTED 10dc72: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc74: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10dc77: f7 d0 not %eax <== NOT EXECUTED 10dc79: 21 05 3c d7 11 00 and %eax,0x11d73c <== NOT EXECUTED } 10dc7f: c9 leave <== NOT EXECUTED 10dc80: c3 ret <== NOT EXECUTED 0010dc63 : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10dc63: 55 push %ebp <== NOT EXECUTED 10dc64: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10dc66: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dc69: 09 05 3c d7 11 00 or %eax,0x11d73c <== NOT EXECUTED } 10dc6f: c9 leave <== NOT EXECUTED 10dc70: c3 ret <== NOT EXECUTED 0010e57b : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 10e57b: 55 push %ebp <== NOT EXECUTED 10e57c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e57e: 53 push %ebx <== NOT EXECUTED 10e57f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 10e582: 50 push %eax <== NOT EXECUTED 10e583: 68 c8 78 11 00 push $0x1178c8 <== NOT EXECUTED 10e588: e8 bb 03 00 00 call 10e948 <== NOT EXECUTED 10e58d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e58f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e592: 85 c0 test %eax,%eax <== NOT EXECUTED 10e594: 74 07 je 10e59d <== NOT EXECUTED { errno = rc; 10e596: e8 1d 0b 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10e59b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 10e59d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10e5a0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e5a3: c9 leave <== NOT EXECUTED 10e5a4: c3 ret <== NOT EXECUTED 00109594 : int rtems_error( int error_flag, const char *printf_format, ... ) { 109594: 55 push %ebp <== NOT EXECUTED 109595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109597: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10959a: 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); 10959d: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1095a0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1095a3: e8 6d fe ff ff call 109415 <== NOT EXECUTED va_end(arglist); return chars_written; } 1095a8: c9 leave <== NOT EXECUTED 1095a9: 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 38 d7 11 00 mov 0x11d738,%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 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 108b79: 40 inc %eax <== NOT EXECUTED 108b7a: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 cf 22 00 00 call 10ae60 <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 108b91: a1 38 d7 11 00 mov 0x11d738,%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 b5 21 00 00 call 10ae80 <_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 67 21 00 00 call 10ae60 <_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 0010ccc8 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10ccc8: 55 push %ebp <== NOT EXECUTED 10ccc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cccb: 57 push %edi <== NOT EXECUTED 10cccc: 56 push %esi <== NOT EXECUTED 10cccd: 53 push %ebx <== NOT EXECUTED 10ccce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccd1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ccd4: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10ccd7: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10ccdc: 85 f6 test %esi,%esi <== NOT EXECUTED 10ccde: 74 61 je 10cd41 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10cce0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10cce5: 85 ff test %edi,%edi <== NOT EXECUTED 10cce7: 74 58 je 10cd41 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10cce9: a1 5c 99 12 00 mov 0x12995c,%eax <== NOT EXECUTED 10ccee: 40 inc %eax <== NOT EXECUTED 10ccef: a3 5c 99 12 00 mov %eax,0x12995c <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10ccf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccf7: 68 8c 9b 12 00 push $0x129b8c <== NOT EXECUTED 10ccfc: e8 c3 0b 00 00 call 10d8c4 <_Objects_Allocate> <== NOT EXECUTED 10cd01: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10cd03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd06: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd08: 75 0c jne 10cd16 <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd0a: e8 b9 17 00 00 call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd0f: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10cd14: eb 2b jmp 10cd41 <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10cd16: 50 push %eax <== NOT EXECUTED 10cd17: 50 push %eax <== NOT EXECUTED 10cd18: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cd1b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd1e: 50 push %eax <== NOT EXECUTED 10cd1f: e8 60 23 00 00 call 10f084 <_User_extensions_Add_set> <== NOT EXECUTED 10cd24: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10cd27: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10cd2a: a1 a8 9b 12 00 mov 0x129ba8,%eax <== NOT EXECUTED 10cd2f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10cd32: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10cd35: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd37: e8 8c 17 00 00 call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd3c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cd3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10cd41: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd44: 5b pop %ebx <== NOT EXECUTED 10cd45: 5e pop %esi <== NOT EXECUTED 10cd46: 5f pop %edi <== NOT EXECUTED 10cd47: c9 leave <== NOT EXECUTED 10cd48: c3 ret <== NOT EXECUTED 0010cd4c : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10cd4c: 55 push %ebp <== NOT EXECUTED 10cd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4f: 53 push %ebx <== NOT EXECUTED 10cd50: 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 10cd53: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cd56: 50 push %eax <== NOT EXECUTED 10cd57: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cd5a: 68 8c 9b 12 00 push $0x129b8c <== NOT EXECUTED 10cd5f: e8 a4 0f 00 00 call 10dd08 <_Objects_Get> <== NOT EXECUTED 10cd64: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10cd66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd69: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10cd6e: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10cd72: 75 30 jne 10cda4 <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10cd74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd77: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd7a: 50 push %eax <== NOT EXECUTED 10cd7b: e8 ec 23 00 00 call 10f16c <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10cd80: 59 pop %ecx <== NOT EXECUTED 10cd81: 58 pop %eax <== NOT EXECUTED 10cd82: 53 push %ebx <== NOT EXECUTED 10cd83: 68 8c 9b 12 00 push $0x129b8c <== NOT EXECUTED 10cd88: e8 ab 0b 00 00 call 10d938 <_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 10cd8d: 58 pop %eax <== NOT EXECUTED 10cd8e: 5a pop %edx <== NOT EXECUTED 10cd8f: 53 push %ebx <== NOT EXECUTED 10cd90: 68 8c 9b 12 00 push $0x129b8c <== NOT EXECUTED 10cd95: e8 3a 0e 00 00 call 10dbd4 <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10cd9a: e8 29 17 00 00 call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd9f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cda1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cda4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cda7: c9 leave <== NOT EXECUTED 10cda8: c3 ret <== NOT EXECUTED 0010afd4 : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10afd4: 55 push %ebp <== NOT EXECUTED 10afd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afd7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10afda: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10afdd: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10afe2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10afe5: 68 bc 19 12 00 push $0x1219bc <== NOT EXECUTED 10afea: e8 ad 10 00 00 call 10c09c <_Objects_Name_to_id_u32> <== NOT EXECUTED 10afef: 8b 04 85 4c b5 11 00 mov 0x11b54c(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10aff6: c9 leave <== NOT EXECUTED 10aff7: c3 ret <== NOT EXECUTED 00109768 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 109768: 55 push %ebp <== NOT EXECUTED 109769: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10976b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 10976e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109771: 6a 00 push $0x0 <== NOT EXECUTED 109773: 6a 01 push $0x1 <== NOT EXECUTED 109775: e8 4e 0a 00 00 call 10a1c8 <_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 d4 8d 00 00 call 10f0b8 <__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 bf 8d 00 00 call 10f0b8 <__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 71 11 00 push $0x117145 <== 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 4b 8d 00 00 call 10f0b8 <__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 38 8d 00 00 call 10f0b8 <__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 4c b5 11 00 mov 0x11b54c,%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 4c b5 11 00 mov 0x11b54c,%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 7d 8c 00 00 call 10f0b8 <__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 0010cb78 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10cb78: 55 push %ebp <== NOT EXECUTED 10cb79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb7b: 57 push %edi <== NOT EXECUTED 10cb7c: 56 push %esi <== NOT EXECUTED 10cb7d: 53 push %ebx <== NOT EXECUTED 10cb7e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10cb81: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cb86: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) <== NOT EXECUTED init_fs_mount_table(); 10cb8d: e8 f2 04 00 00 call 10d084 <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10cb92: 83 3d 88 5e 11 00 00 cmpl $0x0,0x115e88 <== NOT EXECUTED 10cb99: 75 0a jne 10cba5 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0001 ); 10cb9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb9e: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10cba3: eb 2a jmp 10cbcf <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 10cba5: a1 c0 91 11 00 mov 0x1191c0,%eax <== NOT EXECUTED status = mount( 10cbaa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cbad: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10cbb0: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10cbb3: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10cbb6: ff 30 pushl (%eax) <== NOT EXECUTED 10cbb8: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10cbbb: 50 push %eax <== NOT EXECUTED 10cbbc: e8 e8 04 00 00 call 10d0a9 <== NOT EXECUTED &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10cbc1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10cbc4: 40 inc %eax <== NOT EXECUTED 10cbc5: 75 0d jne 10cbd4 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0002 ); 10cbc7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cbca: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10cbcf: e8 94 cb ff ff call 109768 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 10cbd4: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cbd9: 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; 10cbdf: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10cbe2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10cbe5: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10cbe8: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cbed: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cbef: 6a 00 push $0x0 <== NOT EXECUTED 10cbf1: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10cbf4: 53 push %ebx <== NOT EXECUTED 10cbf5: 6a 00 push $0x0 <== NOT EXECUTED 10cbf7: 68 14 76 11 00 push $0x117614 <== NOT EXECUTED 10cbfc: e8 45 97 ff ff call 106346 <== NOT EXECUTED rtems_filesystem_root = loc; 10cc01: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cc06: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10cc09: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cc0e: 89 de mov %ebx,%esi <== NOT EXECUTED 10cc10: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cc12: 6a 00 push $0x0 <== NOT EXECUTED 10cc14: 53 push %ebx <== NOT EXECUTED 10cc15: 6a 00 push $0x0 <== NOT EXECUTED 10cc17: 68 14 76 11 00 push $0x117614 <== NOT EXECUTED 10cc1c: e8 25 97 ff ff call 106346 <== NOT EXECUTED rtems_filesystem_current = loc; 10cc21: a1 4c b5 11 00 mov 0x11b54c,%eax <== NOT EXECUTED 10cc26: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 10cc29: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10cc2e: 89 de mov %ebx,%esi <== NOT EXECUTED 10cc30: 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); 10cc32: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10cc35: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 10cc3a: 68 16 76 11 00 push $0x117616 <== NOT EXECUTED 10cc3f: e8 24 04 00 00 call 10d068 <== NOT EXECUTED if ( status != 0 ) 10cc44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cc47: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc49: 74 0d je 10cc58 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0003 ); 10cc4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc4e: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10cc53: e9 77 ff ff ff jmp 10cbcf <== NOT EXECUTED * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10cc58: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cc5b: 5b pop %ebx <== NOT EXECUTED 10cc5c: 5e pop %esi <== NOT EXECUTED 10cc5d: 5f pop %edi <== NOT EXECUTED 10cc5e: c9 leave <== NOT EXECUTED 10cc5f: c3 ret <== NOT EXECUTED 00120a4c : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 120a4c: 55 push %ebp <== NOT EXECUTED 120a4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120a4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 120a52: 8b 10 mov (%eax),%edx <== NOT EXECUTED 120a54: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 120a57: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 120a59: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 120a5c: c9 leave <== NOT EXECUTED 120a5d: c3 ret <== NOT EXECUTED 0010adc4 : #endif #include const char *rtems_get_version_string(void) { 10adc4: 55 push %ebp <== NOT EXECUTED 10adc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10adc7: b8 38 ce 11 00 mov $0x11ce38,%eax <== NOT EXECUTED 10adcc: c9 leave <== NOT EXECUTED 10adcd: 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 22 03 00 00 jmp 109957 <_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 76 0b 00 00 call 10a1c8 <_Internal_error_Occurred> <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 109652: 89 1d 10 d7 11 00 mov %ebx,0x11d710 <== 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 1c ad 10 00 push $0x10ad1c <== NOT EXECUTED 109660: e8 eb 29 00 00 call 10c050 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 109665: c7 05 18 d8 11 00 00 movl $0x0,0x11d818 <== 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 e0 45 00 00 call 10dc54 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 109674: e8 bb 02 00 00 call 109934 <_API_extensions_Initialization> <== NOT EXECUTED 109679: c7 05 78 d6 11 00 01 movl $0x1,0x11d678 <== 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 ab 27 00 00 call 10be3a <_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 54 23 00 00 call 10b9f0 <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10969c: e8 67 0b 00 00 call 10a208 <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 1096a1: e8 ae 11 00 00 call 10a854 <_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 50 d6 11 00 90 movl $0x11d690,0x11d650 <== NOT EXECUTED 1096ad: d6 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 b4 03 00 00 call 109a70 <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 1096bc: c7 04 24 30 d7 11 00 movl $0x11d730,(%esp) <== NOT EXECUTED 1096c3: e8 28 03 00 00 call 1099f0 <_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 2c d7 11 00 movw $0x0,0x11d72c <== 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 a4 d7 11 movw $0x0,0x11d7a4(%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 c9 25 00 00 call 10bcb4 <_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 6e 08 00 00 call 109f64 <_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 c9 19 00 00 call 10b0cc <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 109703: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109706: e8 a5 01 00 00 call 1098b0 <_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 30 00 00 00 call 109744 <_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 7e 00 00 00 call 1097a3 <_IO_Manager_initialization> <== NOT EXECUTED configuration_table->number_of_device_drivers, configuration_table->maximum_drivers ); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize( configuration_table ); 109725: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109728: e8 eb 00 00 00 call 109818 <_POSIX_API_Initialize> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10972d: c7 05 18 d8 11 00 01 movl $0x1,0x11d818 <== NOT EXECUTED 109734: 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(); 109737: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 10973a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10973d: 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(); 10973e: e9 05 15 00 00 jmp 10ac48 <_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 56 01 00 00 call 10977c <_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 51 03 00 00 jmp 10997d <_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 18 d8 11 00 02 movl $0x2,0x11d818 <== 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 f5 21 00 00 jmp 10b810 <_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 68 12 12 00 mov 0x121268,%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 0010ed8c : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ed8c: 55 push %ebp <== NOT EXECUTED 10ed8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed8f: 56 push %esi <== NOT EXECUTED 10ed90: 53 push %ebx <== NOT EXECUTED 10ed91: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ed94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ed97: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ed9a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10ed9f: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10eda5: 73 20 jae 10edc7 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 10eda7: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10edaa: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10edaf: 8b 54 02 08 mov 0x8(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10edb3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10edb5: 85 d2 test %edx,%edx <== NOT EXECUTED 10edb7: 74 0e je 10edc7 <== NOT EXECUTED 10edb9: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10edbc: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10edbf: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10edc2: 5b pop %ebx <== NOT EXECUTED 10edc3: 5e pop %esi <== NOT EXECUTED 10edc4: 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; 10edc5: ff e2 jmp *%edx <== NOT EXECUTED } 10edc7: 5b pop %ebx <== NOT EXECUTED 10edc8: 5e pop %esi <== NOT EXECUTED 10edc9: c9 leave <== NOT EXECUTED 10edca: c3 ret <== NOT EXECUTED 0010edcc : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10edcc: 55 push %ebp <== NOT EXECUTED 10edcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10edcf: 56 push %esi <== NOT EXECUTED 10edd0: 53 push %ebx <== NOT EXECUTED 10edd1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10edd4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10edd7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10edda: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10eddf: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10ede5: 73 20 jae 10ee07 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 10ede7: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10edea: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10edef: 8b 54 02 14 mov 0x14(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10edf3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10edf5: 85 d2 test %edx,%edx <== NOT EXECUTED 10edf7: 74 0e je 10ee07 <== NOT EXECUTED 10edf9: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10edfc: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10edff: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ee02: 5b pop %ebx <== NOT EXECUTED 10ee03: 5e pop %esi <== NOT EXECUTED 10ee04: 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; 10ee05: ff e2 jmp *%edx <== NOT EXECUTED } 10ee07: 5b pop %ebx <== NOT EXECUTED 10ee08: 5e pop %esi <== NOT EXECUTED 10ee09: c9 leave <== NOT EXECUTED 10ee0a: c3 ret <== NOT EXECUTED 0010dc94 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10dc94: 55 push %ebp <== NOT EXECUTED 10dc95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc97: 56 push %esi <== NOT EXECUTED 10dc98: 53 push %ebx <== NOT EXECUTED 10dc99: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10dc9c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dc9f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10dca2: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10dca7: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10dcad: 73 1f jae 10dcce <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10dcaf: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10dcb2: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10dcb7: 8b 14 02 mov (%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10dcba: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dcbc: 85 d2 test %edx,%edx <== NOT EXECUTED 10dcbe: 74 0e je 10dcce <== NOT EXECUTED 10dcc0: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10dcc3: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10dcc6: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10dcc9: 5b pop %ebx <== NOT EXECUTED 10dcca: 5e pop %esi <== NOT EXECUTED 10dccb: 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; 10dccc: ff e2 jmp *%edx <== NOT EXECUTED } 10dcce: 5b pop %ebx <== NOT EXECUTED 10dccf: 5e pop %esi <== NOT EXECUTED 10dcd0: c9 leave <== NOT EXECUTED 10dcd1: 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 f6 8e 00 00 call 10f0b8 <__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 0010ee0c : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ee0c: 55 push %ebp <== NOT EXECUTED 10ee0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee0f: 56 push %esi <== NOT EXECUTED 10ee10: 53 push %ebx <== NOT EXECUTED 10ee11: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ee14: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ee17: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ee1a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10ee1f: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10ee25: 73 20 jae 10ee47 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 10ee27: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10ee2a: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10ee2f: 8b 54 02 04 mov 0x4(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ee33: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ee35: 85 d2 test %edx,%edx <== NOT EXECUTED 10ee37: 74 0e je 10ee47 <== NOT EXECUTED 10ee39: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ee3c: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ee3f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ee42: 5b pop %ebx <== NOT EXECUTED 10ee43: 5e pop %esi <== NOT EXECUTED 10ee44: 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; 10ee45: ff e2 jmp *%edx <== NOT EXECUTED } 10ee47: 5b pop %ebx <== NOT EXECUTED 10ee48: 5e pop %esi <== NOT EXECUTED 10ee49: c9 leave <== NOT EXECUTED 10ee4a: c3 ret <== NOT EXECUTED 0010ee4c : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ee4c: 55 push %ebp <== NOT EXECUTED 10ee4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee4f: 56 push %esi <== NOT EXECUTED 10ee50: 53 push %ebx <== NOT EXECUTED 10ee51: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ee54: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ee57: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ee5a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10ee5f: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10ee65: 73 20 jae 10ee87 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 10ee67: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10ee6a: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10ee6f: 8b 54 02 0c mov 0xc(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ee73: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ee75: 85 d2 test %edx,%edx <== NOT EXECUTED 10ee77: 74 0e je 10ee87 <== NOT EXECUTED 10ee79: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ee7c: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ee7f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ee82: 5b pop %ebx <== NOT EXECUTED 10ee83: 5e pop %esi <== NOT EXECUTED 10ee84: 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; 10ee85: ff e2 jmp *%edx <== NOT EXECUTED } 10ee87: 5b pop %ebx <== NOT EXECUTED 10ee88: 5e pop %esi <== NOT EXECUTED 10ee89: c9 leave <== NOT EXECUTED 10ee8a: c3 ret <== NOT EXECUTED 0010a4d0 : 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 ) { 10a4d0: 55 push %ebp <== NOT EXECUTED 10a4d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4d3: 57 push %edi <== NOT EXECUTED 10a4d4: 56 push %esi <== NOT EXECUTED 10a4d5: 53 push %ebx <== NOT EXECUTED 10a4d6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a4d9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4dc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a4df: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a4e2: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10a4e5: 85 f6 test %esi,%esi <== NOT EXECUTED 10a4e7: 0f 84 9a 00 00 00 je 10a587 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10a4ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4ef: 0f 84 92 00 00 00 je 10a587 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10a4f5: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 10a4f8: 75 0a jne 10a504 <== NOT EXECUTED 10a4fa: 83 7e 04 00 cmpl $0x0,0x4(%esi) <== NOT EXECUTED 10a4fe: 0f 84 83 00 00 00 je 10a587 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10a504: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a507: 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 ) 10a50d: 8b 15 f0 13 12 00 mov 0x1213f0,%edx <== NOT EXECUTED 10a513: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a518: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10a51a: 73 77 jae 10a593 <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10a51c: 85 db test %ebx,%ebx <== NOT EXECUTED 10a51e: 75 2b jne 10a54b <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a520: 8d 5a ff lea -0x1(%edx),%ebx <== NOT EXECUTED 10a523: 6b c2 18 imul $0x18,%edx,%eax <== NOT EXECUTED 10a526: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a529: 03 05 f4 13 12 00 add 0x1213f4,%eax <== NOT EXECUTED 10a52f: eb 0f jmp 10a540 <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10a531: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a534: 75 06 jne 10a53c <== NOT EXECUTED 10a536: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 10a53a: 74 0f je 10a54b <== NOT EXECUTED * in use. */ if ( major == 0 ) { bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a53c: 4b dec %ebx <== NOT EXECUTED 10a53d: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a540: 85 db test %ebx,%ebx <== NOT EXECUTED 10a542: 75 ed jne 10a531 <== NOT EXECUTED 10a544: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a549: eb 48 jmp 10a593 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10a54b: 6b fb 18 imul $0x18,%ebx,%edi <== NOT EXECUTED 10a54e: 03 3d f4 13 12 00 add 0x1213f4,%edi <== NOT EXECUTED 10a554: 83 3f 00 cmpl $0x0,(%edi) <== NOT EXECUTED 10a557: 75 35 jne 10a58e <== NOT EXECUTED 10a559: 83 7f 04 00 cmpl $0x0,0x4(%edi) <== NOT EXECUTED 10a55d: 75 2f jne 10a58e <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10a55f: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a564: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10a566: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a569: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10a56b: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10a572: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10a579: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10a57c: 5b pop %ebx <== NOT EXECUTED 10a57d: 5e pop %esi <== NOT EXECUTED 10a57e: 5b pop %ebx <== NOT EXECUTED 10a57f: 5e pop %esi <== NOT EXECUTED 10a580: 5f pop %edi <== NOT EXECUTED 10a581: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10a582: e9 ed fd ff ff jmp 10a374 <== NOT EXECUTED 10a587: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a58c: eb 05 jmp 10a593 <== NOT EXECUTED 10a58e: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10a593: 5a pop %edx <== NOT EXECUTED 10a594: 59 pop %ecx <== NOT EXECUTED 10a595: 5b pop %ebx <== NOT EXECUTED 10a596: 5e pop %esi <== NOT EXECUTED 10a597: 5f pop %edi <== NOT EXECUTED 10a598: c9 leave <== NOT EXECUTED 10a599: 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 0010a59c : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10a59c: 55 push %ebp <== NOT EXECUTED 10a59d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a59f: 57 push %edi <== NOT EXECUTED 10a5a0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a5a3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10a5a6: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10a5ab: 3b 15 f0 13 12 00 cmp 0x1213f0,%edx <== NOT EXECUTED 10a5b1: 73 12 jae 10a5c5 <== NOT EXECUTED memset( 10a5b3: 6b fa 18 imul $0x18,%edx,%edi <== NOT EXECUTED 10a5b6: 03 3d f4 13 12 00 add 0x1213f4,%edi <== NOT EXECUTED 10a5bc: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a5c1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a5c3: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10a5c5: 5a pop %edx <== NOT EXECUTED 10a5c6: 5f pop %edi <== NOT EXECUTED 10a5c7: c9 leave <== NOT EXECUTED 10a5c8: c3 ret <== NOT EXECUTED 0010ee8c : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ee8c: 55 push %ebp <== NOT EXECUTED 10ee8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee8f: 56 push %esi <== NOT EXECUTED 10ee90: 53 push %ebx <== NOT EXECUTED 10ee91: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ee94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ee97: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ee9a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10ee9f: 3b 0d f0 df 11 00 cmp 0x11dff0,%ecx <== NOT EXECUTED 10eea5: 73 20 jae 10eec7 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 10eea7: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10eeaa: a1 f4 df 11 00 mov 0x11dff4,%eax <== NOT EXECUTED 10eeaf: 8b 54 02 10 mov 0x10(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10eeb3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10eeb5: 85 d2 test %edx,%edx <== NOT EXECUTED 10eeb7: 74 0e je 10eec7 <== NOT EXECUTED 10eeb9: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10eebc: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10eebf: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10eec2: 5b pop %ebx <== NOT EXECUTED 10eec3: 5e pop %esi <== NOT EXECUTED 10eec4: 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; 10eec5: ff e2 jmp *%edx <== NOT EXECUTED } 10eec7: 5b pop %ebx <== NOT EXECUTED 10eec8: 5e pop %esi <== NOT EXECUTED 10eec9: c9 leave <== NOT EXECUTED 10eeca: c3 ret <== NOT EXECUTED 0010b4ac : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10b4ac: 55 push %ebp <== NOT EXECUTED 10b4ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4af: 57 push %edi <== NOT EXECUTED 10b4b0: 56 push %esi <== NOT EXECUTED 10b4b1: 53 push %ebx <== NOT EXECUTED 10b4b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10b4b5: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10b4b9: 74 41 je 10b4fc <== NOT EXECUTED return; 10b4bb: 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 ] ) 10b4c0: 8b 04 bd e8 93 12 00 mov 0x1293e8(,%edi,4),%eax <== NOT EXECUTED 10b4c7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4c9: 74 2b je 10b4f6 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10b4cb: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10b4ce: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10b4d3: 85 f6 test %esi,%esi <== NOT EXECUTED 10b4d5: 75 17 jne 10b4ee <== NOT EXECUTED 10b4d7: eb 1d jmp 10b4f6 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10b4d9: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10b4dc: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10b4df: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4e1: 74 0a je 10b4ed <== NOT EXECUTED continue; (*routine)(the_thread); 10b4e3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b4e6: 50 push %eax <== NOT EXECUTED 10b4e7: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10b4ea: 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++ ) { 10b4ed: 43 inc %ebx <== NOT EXECUTED 10b4ee: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10b4f2: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b4f4: 76 e3 jbe 10b4d9 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10b4f6: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10b4f7: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10b4fa: 75 c4 jne 10b4c0 <== NOT EXECUTED (*routine)(the_thread); } } } } 10b4fc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4ff: 5b pop %ebx <== NOT EXECUTED 10b500: 5e pop %esi <== NOT EXECUTED 10b501: 5f pop %edi <== NOT EXECUTED 10b502: c9 leave <== NOT EXECUTED 10b503: c3 ret <== NOT EXECUTED 0010cfa1 : * 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 ) { 10cfa1: 55 push %ebp <== NOT EXECUTED 10cfa2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfa4: 57 push %edi <== NOT EXECUTED 10cfa5: 53 push %ebx <== NOT EXECUTED 10cfa6: 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 ); 10cfa9: 6a 00 push $0x0 <== NOT EXECUTED 10cfab: 6a 00 push $0x0 <== NOT EXECUTED 10cfad: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cfb3: e8 90 c1 ff ff call 109148 <== NOT EXECUTED if (rtems_libio_iop_freelist) { 10cfb8: 8b 15 1c d5 11 00 mov 0x11d51c,%edx <== NOT EXECUTED 10cfbe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfc1: 85 d2 test %edx,%edx <== NOT EXECUTED 10cfc3: 74 55 je 10d01a <== NOT EXECUTED rc = rtems_semaphore_create( 10cfc5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfc8: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10cfcb: 50 push %eax <== NOT EXECUTED 10cfcc: 6a 00 push $0x0 <== NOT EXECUTED 10cfce: 6a 54 push $0x54 <== NOT EXECUTED 10cfd0: 6a 01 push $0x1 <== NOT EXECUTED 10cfd2: 2b 15 18 d5 11 00 sub 0x11d518,%edx <== NOT EXECUTED 10cfd8: c1 fa 02 sar $0x2,%edx <== NOT EXECUTED 10cfdb: 69 c2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%eax <== NOT EXECUTED 10cfe1: 0d 00 49 42 4c or $0x4c424900,%eax <== NOT EXECUTED 10cfe6: 50 push %eax <== NOT EXECUTED 10cfe7: e8 28 bf ff ff call 108f14 <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10cfec: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10cfef: 85 c0 test %eax,%eax <== NOT EXECUTED 10cff1: 75 27 jne 10d01a <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 10cff3: 8b 1d 1c d5 11 00 mov 0x11d51c,%ebx <== NOT EXECUTED next = iop->data1; 10cff9: 8b 53 28 mov 0x28(%ebx),%edx <== NOT EXECUTED (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10cffc: b9 0d 00 00 00 mov $0xd,%ecx <== NOT EXECUTED 10d001: 89 df mov %ebx,%edi <== NOT EXECUTED 10d003: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED iop->flags = LIBIO_FLAGS_OPEN; 10d005: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) <== NOT EXECUTED iop->sem = sema; 10d00c: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10d00f: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = next; 10d012: 89 15 1c d5 11 00 mov %edx,0x11d51c <== NOT EXECUTED 10d018: eb 02 jmp 10d01c <== NOT EXECUTED } failed: iop = 0; done: 10d01a: 31 db xor %ebx,%ebx <== NOT EXECUTED rtems_semaphore_release( rtems_libio_semaphore ); 10d01c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d01f: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10d025: e8 06 c2 ff ff call 109230 <== NOT EXECUTED return iop; } 10d02a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d02c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d02f: 5b pop %ebx <== NOT EXECUTED 10d030: 5f pop %edi <== NOT EXECUTED 10d031: c9 leave <== NOT EXECUTED 10d032: c3 ret <== NOT EXECUTED 0010d033 : }; uint32_t rtems_libio_fcntl_flags( uint32_t fcntl_flags ) { 10d033: 55 push %ebp <== NOT EXECUTED 10d034: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d036: 56 push %esi <== NOT EXECUTED 10d037: 53 push %ebx <== NOT EXECUTED 10d038: 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 ); 10d03b: 51 push %ecx <== NOT EXECUTED 10d03c: 51 push %ecx <== NOT EXECUTED 10d03d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d03f: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10d042: 50 push %eax <== NOT EXECUTED 10d043: 68 44 76 11 00 push $0x117644 <== NOT EXECUTED 10d048: e8 8f 18 00 00 call 10e8dc <== NOT EXECUTED 10d04d: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Everything else is single bits */ flags |= 10d04f: 58 pop %eax <== NOT EXECUTED 10d050: 5a pop %edx <== NOT EXECUTED 10d051: 83 e3 fc and $0xfffffffc,%ebx <== NOT EXECUTED 10d054: 53 push %ebx <== NOT EXECUTED 10d055: 68 74 76 11 00 push $0x117674 <== NOT EXECUTED 10d05a: e8 41 18 00 00 call 10e8a0 <== NOT EXECUTED 10d05f: 09 f0 or %esi,%eax <== NOT EXECUTED rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags); return flags; } 10d061: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d064: 5b pop %ebx <== NOT EXECUTED 10d065: 5e pop %esi <== NOT EXECUTED 10d066: c9 leave <== NOT EXECUTED 10d067: c3 ret <== NOT EXECUTED 0010cf4c : */ void rtems_libio_free( rtems_libio_t *iop ) { 10cf4c: 55 push %ebp <== NOT EXECUTED 10cf4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf4f: 53 push %ebx <== NOT EXECUTED 10cf50: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cf53: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10cf56: 6a 00 push $0x0 <== NOT EXECUTED 10cf58: 6a 00 push $0x0 <== NOT EXECUTED 10cf5a: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cf60: e8 e3 c1 ff ff call 109148 <== NOT EXECUTED if (iop->sem) 10cf65: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10cf68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf6b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf6d: 74 0c je 10cf7b <== NOT EXECUTED rtems_semaphore_delete(iop->sem); 10cf6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf72: 50 push %eax <== NOT EXECUTED 10cf73: e8 40 c1 ff ff call 1090b8 <== NOT EXECUTED 10cf78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10cf7b: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) <== NOT EXECUTED iop->data1 = rtems_libio_iop_freelist; 10cf82: a1 1c d5 11 00 mov 0x11d51c,%eax <== NOT EXECUTED 10cf87: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = iop; 10cf8a: 89 1d 1c d5 11 00 mov %ebx,0x11d51c <== NOT EXECUTED rtems_semaphore_release(rtems_libio_semaphore); 10cf90: a1 20 d5 11 00 mov 0x11d520,%eax <== NOT EXECUTED 10cf95: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cf98: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cf9b: 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); 10cf9c: e9 8f c2 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 b8 91 11 00 mov 0x1191b8,%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 66 67 00 00 call 10cc60 <== NOT EXECUTED 1064fa: 89 c1 mov %eax,%ecx <== NOT EXECUTED 1064fc: a3 18 d5 11 00 mov %eax,0x11d518 <== 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 1c d5 11 00 mov %eax,0x11d51c <== NOT EXECUTED for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 106514: 8b 1d b8 91 11 00 mov 0x1191b8,%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 20 d5 11 00 push $0x11d520 <== 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 0a 32 00 00 call 109768 <== 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 11 66 00 00 jmp 10cb78 <== NOT EXECUTED 0010ce94 : */ int rtems_libio_is_file_open( void *node_access ) { 10ce94: 55 push %ebp <== NOT EXECUTED 10ce95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce97: 53 push %ebx <== NOT EXECUTED 10ce98: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ce9b: 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 ); 10ce9e: 6a 00 push $0x0 <== NOT EXECUTED 10cea0: 6a 00 push $0x0 <== NOT EXECUTED 10cea2: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cea8: e8 9b 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++){ 10cead: a1 18 d5 11 00 mov 0x11d518,%eax <== NOT EXECUTED 10ceb2: 8b 0d b8 91 11 00 mov 0x1191b8,%ecx <== NOT EXECUTED 10ceb8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ceba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cebd: eb 16 jmp 10ced5 <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10cebf: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 10cec3: 74 0c je 10ced1 <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10cec5: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 10cec8: 75 07 jne 10ced1 <== NOT EXECUTED 10ceca: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10cecf: eb 0a jmp 10cedb <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ced1: 83 c0 34 add $0x34,%eax <== NOT EXECUTED 10ced4: 42 inc %edx <== NOT EXECUTED 10ced5: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10ced7: 72 e6 jb 10cebf <== NOT EXECUTED 10ced9: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10cedb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cede: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cee4: e8 47 c3 ff ff call 109230 <== NOT EXECUTED return result; } 10cee9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ceeb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ceee: c9 leave <== NOT EXECUTED 10ceef: c3 ret <== NOT EXECUTED 0010cef0 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10cef0: 55 push %ebp <== NOT EXECUTED 10cef1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cef3: 53 push %ebx <== NOT EXECUTED 10cef4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cef7: 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 ); 10cefa: 6a 00 push $0x0 <== NOT EXECUTED 10cefc: 6a 00 push $0x0 <== NOT EXECUTED 10cefe: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cf04: e8 3f 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++){ 10cf09: a1 18 d5 11 00 mov 0x11d518,%eax <== NOT EXECUTED 10cf0e: 8b 0d b8 91 11 00 mov 0x1191b8,%ecx <== NOT EXECUTED 10cf14: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cf16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf19: eb 16 jmp 10cf31 <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10cf1b: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 10cf1f: 74 0c je 10cf2d <== 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 ) { 10cf21: 39 58 1c cmp %ebx,0x1c(%eax) <== NOT EXECUTED 10cf24: 75 07 jne 10cf2d <== NOT EXECUTED 10cf26: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10cf2b: eb 0a jmp 10cf37 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10cf2d: 83 c0 34 add $0x34,%eax <== NOT EXECUTED 10cf30: 42 inc %edx <== NOT EXECUTED 10cf31: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10cf33: 72 e6 jb 10cf1b <== NOT EXECUTED 10cf35: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10cf37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf3a: ff 35 20 d5 11 00 pushl 0x11d520 <== NOT EXECUTED 10cf40: e8 eb c2 ff ff call 109230 <== NOT EXECUTED return result; } 10cf45: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cf47: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cf4a: c9 leave <== NOT EXECUTED 10cf4b: c3 ret <== NOT EXECUTED 001204b1 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 1204b1: 55 push %ebp <== NOT EXECUTED 1204b2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1204b4: 57 push %edi <== NOT EXECUTED 1204b5: 56 push %esi <== NOT EXECUTED 1204b6: 53 push %ebx <== NOT EXECUTED 1204b7: 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); 1204ba: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1204bd: 50 push %eax <== NOT EXECUTED 1204be: 6a 00 push $0x0 <== NOT EXECUTED 1204c0: 6a 00 push $0x0 <== NOT EXECUTED 1204c2: e8 c5 12 00 00 call 12178c <== NOT EXECUTED 1204c7: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 1204c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1204cc: 85 c0 test %eax,%eax <== NOT EXECUTED 1204ce: 0f 85 d4 00 00 00 jne 1205a8 <== NOT EXECUTED /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 1204d4: 81 3d a4 4b 14 00 58 cmpl $0x15b358,0x144ba4 <== NOT EXECUTED 1204db: b3 15 00 <== NOT EXECUTED 1204de: 75 4e jne 12052e <== NOT EXECUTED rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 1204e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1204e3: 6a 40 push $0x40 <== NOT EXECUTED 1204e5: e8 f2 9f fe ff call 10a4dc <== NOT EXECUTED 1204ea: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!tmp) 1204ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1204ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1204f1: 75 07 jne 1204fa <== NOT EXECUTED 1204f3: b3 1a mov $0x1a,%bl <== NOT EXECUTED 1204f5: e9 ae 00 00 00 jmp 1205a8 <== 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); 1204fa: 57 push %edi <== NOT EXECUTED 1204fb: 68 bc 03 12 00 push $0x1203bc <== NOT EXECUTED 120500: 68 a4 4b 14 00 push $0x144ba4 <== NOT EXECUTED 120505: 6a 00 push $0x0 <== NOT EXECUTED 120507: e8 e4 15 00 00 call 121af0 <== NOT EXECUTED 12050c: 89 c7 mov %eax,%edi <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 12050e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120511: 85 c0 test %eax,%eax <== NOT EXECUTED 120513: 74 13 je 120528 <== NOT EXECUTED /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 120515: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120518: 56 push %esi <== NOT EXECUTED 120519: e8 fe 9a fe ff call 10a01c <== NOT EXECUTED 12051e: 89 fb mov %edi,%ebx <== NOT EXECUTED 120520: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120523: e9 80 00 00 00 jmp 1205a8 <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; 120528: 89 35 a4 4b 14 00 mov %esi,0x144ba4 <== NOT EXECUTED }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 12052e: 8b 3d a4 4b 14 00 mov 0x144ba4,%edi <== NOT EXECUTED 120534: be 58 b3 15 00 mov $0x15b358,%esi <== NOT EXECUTED 120539: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 12053e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_current_user_env->task_id=task_id; /* mark the local values*/ 120540: 8b 15 a4 4b 14 00 mov 0x144ba4,%edx <== NOT EXECUTED 120546: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120549: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 12054b: 8d 7a 14 lea 0x14(%edx),%edi <== NOT EXECUTED 12054e: a1 fc ab 15 00 mov 0x15abfc,%eax <== NOT EXECUTED 120553: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 120556: b1 04 mov $0x4,%cl <== NOT EXECUTED 120558: 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); 12055a: 6a 00 push $0x0 <== NOT EXECUTED 12055c: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 12055f: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 120562: 50 push %eax <== NOT EXECUTED 120563: 6a 00 push $0x0 <== NOT EXECUTED 120565: 68 e7 dd 13 00 push $0x13dde7 <== NOT EXECUTED 12056a: e8 8b 99 fe ff call 109efa <== NOT EXECUTED rtems_filesystem_root = loc; 12056f: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 120574: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 120577: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12057c: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 12057f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_evaluate_path("/", 0, &loc, 0); 120581: 6a 00 push $0x0 <== NOT EXECUTED 120583: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 120586: 50 push %eax <== NOT EXECUTED 120587: 6a 00 push $0x0 <== NOT EXECUTED 120589: 68 e7 dd 13 00 push $0x13dde7 <== NOT EXECUTED 12058e: e8 67 99 fe ff call 109efa <== NOT EXECUTED rtems_filesystem_current = loc; 120593: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 120598: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12059b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1205a0: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 1205a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1205a5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1205a8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1205aa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1205ad: 5b pop %ebx <== NOT EXECUTED 1205ae: 5e pop %esi <== NOT EXECUTED 1205af: 5f pop %edi <== NOT EXECUTED 1205b0: c9 leave <== NOT EXECUTED 1205b1: c3 ret <== NOT EXECUTED 00120413 : * 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) { 120413: 55 push %ebp <== NOT EXECUTED 120414: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120416: 53 push %ebx <== NOT EXECUTED 120417: 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); 12041a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12041d: 50 push %eax <== NOT EXECUTED 12041e: 6a 00 push $0x0 <== NOT EXECUTED 120420: 6a 00 push $0x0 <== NOT EXECUTED 120422: e8 65 13 00 00 call 12178c <== NOT EXECUTED 120427: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 120429: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12042c: 85 c0 test %eax,%eax <== NOT EXECUTED 12042e: 75 7a jne 1204aa <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 120430: 8b 1d a4 4b 14 00 mov 0x144ba4,%ebx <== NOT EXECUTED 120436: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 120438: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED 12043b: 75 23 jne 120460 <== 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); 12043d: 51 push %ecx <== NOT EXECUTED 12043e: 51 push %ecx <== NOT EXECUTED 12043f: 68 a4 4b 14 00 push $0x144ba4 <== NOT EXECUTED 120444: 6a 00 push $0x0 <== NOT EXECUTED 120446: e8 3d 17 00 00 call 121b88 <== NOT EXECUTED 12044b: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 12044d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120450: 85 c0 test %eax,%eax <== NOT EXECUTED 120452: 75 56 jne 1204aa <== NOT EXECUTED free_user_env(tmp); 120454: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120457: 53 push %ebx <== NOT EXECUTED 120458: e8 5f ff ff ff call 1203bc <== NOT EXECUTED 12045d: 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, 120460: 52 push %edx <== NOT EXECUTED 120461: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 120464: 50 push %eax <== NOT EXECUTED 120465: 68 a4 4b 14 00 push $0x144ba4 <== NOT EXECUTED 12046a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12046d: e8 96 17 00 00 call 121c08 <== NOT EXECUTED 120472: 89 c2 mov %eax,%edx <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 120474: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120477: 85 c0 test %eax,%eax <== NOT EXECUTED 120479: 75 25 jne 1204a0 <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 12047b: 50 push %eax <== NOT EXECUTED 12047c: 68 bc 03 12 00 push $0x1203bc <== NOT EXECUTED 120481: 68 a4 4b 14 00 push $0x144ba4 <== NOT EXECUTED 120486: 6a 00 push $0x0 <== NOT EXECUTED 120488: e8 63 16 00 00 call 121af0 <== NOT EXECUTED 12048d: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 12048f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120492: 85 c0 test %eax,%eax <== NOT EXECUTED 120494: 75 0a jne 1204a0 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 120496: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 120499: a3 a4 4b 14 00 mov %eax,0x144ba4 <== NOT EXECUTED 12049e: eb 0a jmp 1204aa <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 1204a0: c7 05 a4 4b 14 00 58 movl $0x15b358,0x144ba4 <== NOT EXECUTED 1204a7: b3 15 00 <== NOT EXECUTED return sc; } 1204aa: 89 d0 mov %edx,%eax <== NOT EXECUTED 1204ac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1204af: c9 leave <== NOT EXECUTED 1204b0: c3 ret <== NOT EXECUTED 0010ce54 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10ce54: 55 push %ebp <== NOT EXECUTED 10ce55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce57: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10ce5a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10ce5c: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10ce5f: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED 10ce64: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10ce67: 74 0f je 10ce78 <== NOT EXECUTED fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10ce69: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ce6b: f6 c1 02 test $0x2,%cl <== NOT EXECUTED 10ce6e: 75 08 jne 10ce78 <== NOT EXECUTED 10ce70: 89 ca mov %ecx,%edx <== NOT EXECUTED 10ce72: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 10ce75: 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 ) { 10ce78: f6 c1 01 test $0x1,%cl <== NOT EXECUTED 10ce7b: 74 03 je 10ce80 <== NOT EXECUTED fcntl_flags |= O_NONBLOCK; 10ce7d: 80 ce 40 or $0x40,%dh <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10ce80: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 10ce83: 74 03 je 10ce88 <== NOT EXECUTED fcntl_flags |= O_APPEND; 10ce85: 83 ca 08 or $0x8,%edx <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10ce88: 80 e5 04 and $0x4,%ch <== NOT EXECUTED 10ce8b: 74 03 je 10ce90 <== NOT EXECUTED fcntl_flags |= O_CREAT; 10ce8d: 80 ce 02 or $0x2,%dh <== NOT EXECUTED } return fcntl_flags; } 10ce90: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ce92: c9 leave <== NOT EXECUTED 10ce93: 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 78 ab 15 00 push $0x15ab78 <== NOT EXECUTED 10a586: e8 b9 4e 00 00 call 10f444 <_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 f4 ab 15 00 add %eax,0x15abf4 <== NOT EXECUTED 10a59d: 11 15 f8 ab 15 00 adc %edx,0x15abf8 <== 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 78 ab 15 00 push $0x15ab78 <== NOT EXECUTED 10a5c4: e8 7b 4e 00 00 call 10f444 <_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 ec ab 15 00 add 0x15abec,%eax <== NOT EXECUTED 10a5d4: 13 15 f0 ab 15 00 adc 0x15abf0,%edx <== NOT EXECUTED 10a5da: a3 ec ab 15 00 mov %eax,0x15abec <== NOT EXECUTED 10a5df: 89 15 f0 ab 15 00 mov %edx,0x15abf0 <== NOT EXECUTED current_depth = s->lifetime_allocated - s->lifetime_freed; 10a5e5: 2b 05 f4 ab 15 00 sub 0x15abf4,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10a5eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5ee: 3b 05 e8 ab 15 00 cmp 0x15abe8,%eax <== NOT EXECUTED 10a5f4: 76 05 jbe 10a5fb <== NOT EXECUTED s->max_depth = current_depth; 10a5f6: a3 e8 ab 15 00 mov %eax,0x15abe8 <== 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 d0 ab 15 00 mov $0x15abd0,%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 44 1b 12 00 03 cmpl $0x3,0x121b44 <== 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 5c 18 12 00 push $0x12185c <== NOT EXECUTED 108605: e8 06 40 00 00 call 10c610 <_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 54 f9 11 00 mov 0x11f954,%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 38 49 13 00 push $0x134938 <== NOT EXECUTED 110cc9: e8 fe 42 00 00 call 114fcc <_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 eb 2d 00 00 call 113adc <_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 91 4a 00 00 call 11578c <_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 cc ac 15 00 mov 0x15accc,%eax <== NOT EXECUTED 10d44e: 40 inc %eax <== NOT EXECUTED 10d44f: a3 cc ac 15 00 mov %eax,0x15accc <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10d454: e8 df 3f 01 00 call 121438 <_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 7c 25 00 00 call 10f9e0 <_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 2f 0e 00 00 call 10e2bc <_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 f0 b6 15 00 push $0x15b6f0 <== NOT EXECUTED 10d49c: e8 c3 1a 00 00 call 10ef64 <_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 3a 25 00 00 call 10f9e0 <_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 0c b7 15 00 mov 0x15b70c,%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 12 25 00 00 call 10f9e0 <_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 00112af0 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 112af0: 55 push %ebp <== NOT EXECUTED 112af1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112af3: 53 push %ebx <== NOT EXECUTED 112af4: 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, 112af7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112afa: 50 push %eax <== NOT EXECUTED 112afb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112afe: 68 cc a2 12 00 push $0x12a2cc <== NOT EXECUTED 112b03: e8 00 b2 ff ff call 10dd08 <_Objects_Get> <== NOT EXECUTED 112b08: 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 ) { 112b0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b0d: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112b12: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112b16: 75 34 jne 112b4c <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 112b18: 51 push %ecx <== NOT EXECUTED 112b19: 51 push %ecx <== NOT EXECUTED 112b1a: 53 push %ebx <== NOT EXECUTED 112b1b: 68 cc a2 12 00 push $0x12a2cc <== NOT EXECUTED 112b20: e8 13 ae ff ff call 10d938 <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 112b25: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 112b28: 6a 05 push $0x5 <== NOT EXECUTED 112b2a: 6a 00 push $0x0 <== NOT EXECUTED 112b2c: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 112b2f: 50 push %eax <== NOT EXECUTED 112b30: e8 7b 04 00 00 call 112fb0 <_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, 112b35: 58 pop %eax <== NOT EXECUTED 112b36: 5a pop %edx <== NOT EXECUTED 112b37: 53 push %ebx <== NOT EXECUTED 112b38: 68 cc a2 12 00 push $0x12a2cc <== NOT EXECUTED 112b3d: e8 92 b0 ff ff call 10dbd4 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 112b42: e8 81 b9 ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 112b47: 31 c0 xor %eax,%eax <== NOT EXECUTED 112b49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112b4c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112b4f: c9 leave <== NOT EXECUTED 112b50: 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 38 49 13 00 push $0x134938 <== NOT EXECUTED 110e74: e8 53 41 00 00 call 114fcc <_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 e7 2c 00 00 call 113b7c <_CORE_message_queue_Flush> <== NOT EXECUTED 110e95: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 110e97: e8 f0 48 00 00 call 11578c <_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 38 49 13 00 push $0x134938 <== NOT EXECUTED 110ec8: e8 ff 40 00 00 call 114fcc <_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 a5 48 00 00 call 11578c <_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 70 df 11 00 push $0x11df70 <== NOT EXECUTED 108e84: e8 5f 19 00 00 call 10a7e8 <_Objects_Name_to_id_u32> <== NOT EXECUTED 108e89: 8b 04 85 68 72 11 00 mov 0x117268(,%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 00112b54 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 112b54: 55 push %ebp <== NOT EXECUTED 112b55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112b57: 57 push %edi <== NOT EXECUTED 112b58: 56 push %esi <== NOT EXECUTED 112b59: 53 push %ebx <== NOT EXECUTED 112b5a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112b5d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 112b60: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 112b63: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 112b66: 85 ff test %edi,%edi <== NOT EXECUTED 112b68: 74 5d je 112bc7 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 112b6a: 85 f6 test %esi,%esi <== NOT EXECUTED 112b6c: 74 59 je 112bc7 <== 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, 112b6e: 52 push %edx <== NOT EXECUTED 112b6f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112b72: 50 push %eax <== NOT EXECUTED 112b73: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112b76: 68 cc a2 12 00 push $0x12a2cc <== NOT EXECUTED 112b7b: e8 88 b1 ff ff call 10dd08 <_Objects_Get> <== NOT EXECUTED 112b80: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112b82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b85: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112b8a: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112b8e: 75 3c jne 112bcc <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 112b90: 50 push %eax <== NOT EXECUTED 112b91: 50 push %eax <== NOT EXECUTED 112b92: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 112b95: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 112b98: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 112b9b: 53 push %ebx <== NOT EXECUTED 112b9c: 56 push %esi <== NOT EXECUTED 112b9d: 57 push %edi <== NOT EXECUTED 112b9e: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 112ba1: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 112ba4: 50 push %eax <== NOT EXECUTED 112ba5: e8 56 05 00 00 call 113100 <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 112baa: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112bad: e8 16 b9 ff ff call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 112bb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112bb5: a1 1c 9a 12 00 mov 0x129a1c,%eax <== NOT EXECUTED 112bba: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 112bbd: e8 ee 96 ff ff call 10c2b0 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 112bc2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112bc5: eb 05 jmp 112bcc <== NOT EXECUTED 112bc7: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bcc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112bcf: 5b pop %ebx <== NOT EXECUTED 112bd0: 5e pop %esi <== NOT EXECUTED 112bd1: 5f pop %edi <== NOT EXECUTED 112bd2: c9 leave <== NOT EXECUTED 112bd3: 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 70 df 11 00 push $0x11df70 <== NOT EXECUTED 108eb6: e8 e5 17 00 00 call 10a6a0 <_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 28 0c 00 00 call 109b0c <_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 72 1f 00 00 call 10ae60 <_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 38 49 13 00 push $0x134938 <== NOT EXECUTED 111036: e8 91 3f 00 00 call 114fcc <_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 6c 2d 00 00 call 113dd0 <_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 1e 47 00 00 call 11578c <_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 0010937c : #include int rtems_object_api_maximum_class( uint32_t api ) { 10937c: 55 push %ebp <== NOT EXECUTED 10937d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10937f: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 109380: e9 37 14 00 00 jmp 10a7bc <_Objects_API_maximum_class> <== NOT EXECUTED 00109388 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 109388: 55 push %ebp <== NOT EXECUTED 109389: 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. 10938b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10938e: 48 dec %eax <== NOT EXECUTED 10938f: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109392: 19 c0 sbb %eax,%eax <== NOT EXECUTED 109394: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 109397: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 109398: c9 leave <== NOT EXECUTED 109399: c3 ret <== NOT EXECUTED 0010939c : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10939c: 55 push %ebp <== NOT EXECUTED 10939d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10939f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1093a2: 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 ) 1093a5: b8 e8 e8 11 00 mov $0x11e8e8,%eax <== NOT EXECUTED 1093aa: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1093ad: 74 19 je 1093c8 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 1093af: b8 00 e9 11 00 mov $0x11e900,%eax <== NOT EXECUTED 1093b4: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 1093b7: 74 0f je 1093c8 <== NOT EXECUTED api_assoc = rtems_object_api_classic_assoc; #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) 1093b9: b8 88 99 11 00 mov $0x119988,%eax <== NOT EXECUTED 1093be: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 1093c1: 75 20 jne 1093e3 <== NOT EXECUTED 1093c3: b8 78 e9 11 00 mov $0x11e978,%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 ); 1093c8: 52 push %edx <== NOT EXECUTED 1093c9: 52 push %edx <== NOT EXECUTED 1093ca: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1093cd: 50 push %eax <== NOT EXECUTED 1093ce: e8 b5 3e 00 00 call 10d288 <== NOT EXECUTED 1093d3: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( class_assoc ) 1093d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1093d8: b8 90 99 11 00 mov $0x119990,%eax <== NOT EXECUTED 1093dd: 85 d2 test %edx,%edx <== NOT EXECUTED 1093df: 74 02 je 1093e3 <== NOT EXECUTED return class_assoc->name; 1093e1: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 1093e3: c9 leave <== NOT EXECUTED 1093e4: c3 ret <== NOT EXECUTED 001093e8 : }; const char *rtems_object_get_api_name( uint32_t api ) { 1093e8: 55 push %ebp <== NOT EXECUTED 1093e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1093eb: 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 ); 1093ee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1093f1: 68 08 ea 11 00 push $0x11ea08 <== NOT EXECUTED 1093f6: e8 8d 3e 00 00 call 10d288 <== NOT EXECUTED 1093fb: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( api_assoc ) 1093fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109400: b8 90 99 11 00 mov $0x119990,%eax <== NOT EXECUTED 109405: 85 d2 test %edx,%edx <== NOT EXECUTED 109407: 74 02 je 10940b <== NOT EXECUTED return api_assoc->name; 109409: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 10940b: c9 leave <== NOT EXECUTED 10940c: c3 ret <== NOT EXECUTED 0010a428 : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10a428: 55 push %ebp <== NOT EXECUTED 10a429: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a42b: 57 push %edi <== NOT EXECUTED 10a42c: 56 push %esi <== NOT EXECUTED 10a42d: 53 push %ebx <== NOT EXECUTED 10a42e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a431: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10a434: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a439: 85 ff test %edi,%edi <== NOT EXECUTED 10a43b: 74 50 je 10a48d <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10a43d: 50 push %eax <== NOT EXECUTED 10a43e: 50 push %eax <== NOT EXECUTED 10a43f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a442: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a445: e8 3a 18 00 00 call 10bc84 <_Objects_Get_information> <== NOT EXECUTED 10a44a: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !obj_info ) 10a44c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a44f: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a454: 85 db test %ebx,%ebx <== NOT EXECUTED 10a456: 74 35 je 10a48d <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10a458: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a45b: 89 07 mov %eax,(%edi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10a45d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a460: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10a463: 8a 43 12 mov 0x12(%ebx),%al <== NOT EXECUTED 10a466: 88 47 0c mov %al,0xc(%edi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10a469: 0f b7 73 10 movzwl 0x10(%ebx),%esi <== NOT EXECUTED 10a46d: 89 77 08 mov %esi,0x8(%edi) <== NOT EXECUTED 10a470: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a472: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a477: eb 0b jmp 10a484 <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) if ( !obj_info->local_table[i] ) 10a479: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED unallocated++; 10a47c: 83 3c 90 01 cmpl $0x1,(%eax,%edx,4) <== NOT EXECUTED 10a480: 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++ ) 10a483: 42 inc %edx <== NOT EXECUTED 10a484: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a486: 76 f1 jbe 10a479 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10a488: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED 10a48b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a48d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a490: 5b pop %ebx <== NOT EXECUTED 10a491: 5e pop %esi <== NOT EXECUTED 10a492: 5f pop %edi <== NOT EXECUTED 10a493: c9 leave <== NOT EXECUTED 10a494: 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 f7 18 00 00 call 10b640 <_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 40 a4 11 00 mov 0x11a440(,%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 00112c48 : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 112c48: 55 push %ebp <== NOT EXECUTED 112c49: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 112c4b: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 112c4c: e9 2b 09 00 00 jmp 11357c <_Objects_Get_name_as_string> <== NOT EXECUTED 0010a4a4 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10a4a4: 55 push %ebp <== NOT EXECUTED 10a4a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10a4a7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a4ac: c9 leave <== NOT EXECUTED 10a4ad: c3 ret <== NOT EXECUTED 0010a4b0 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10a4b0: 55 push %ebp <== NOT EXECUTED 10a4b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10a4b3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a4b8: c9 leave <== NOT EXECUTED 10a4b9: c3 ret <== NOT EXECUTED 0010a4bc : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10a4bc: 55 push %ebp <== NOT EXECUTED 10a4bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4bf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4c2: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a4c5: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10a4c8: c9 leave <== NOT EXECUTED 10a4c9: c3 ret <== NOT EXECUTED 0010a4cc : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10a4cc: 55 push %ebp <== NOT EXECUTED 10a4cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4cf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4d2: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10a4d5: c9 leave <== NOT EXECUTED 10a4d6: c3 ret <== NOT EXECUTED 0010a4d8 : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10a4df: c9 leave <== NOT EXECUTED 10a4e0: c3 ret <== NOT EXECUTED 0010a4e4 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10a4e4: 55 push %ebp <== NOT EXECUTED 10a4e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4e7: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10a4eb: c9 leave <== NOT EXECUTED 10a4ec: c3 ret <== NOT EXECUTED 0010941c : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10941c: 55 push %ebp <== NOT EXECUTED 10941d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10941f: 57 push %edi <== NOT EXECUTED 109420: 56 push %esi <== NOT EXECUTED 109421: 53 push %ebx <== NOT EXECUTED 109422: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109425: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 109428: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10942d: 85 ff test %edi,%edi <== NOT EXECUTED 10942f: 74 50 je 109481 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 109431: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109434: 85 db test %ebx,%ebx <== NOT EXECUTED 109436: 75 08 jne 109440 <== NOT EXECUTED 109438: a1 2c 0c 12 00 mov 0x120c2c,%eax <== NOT EXECUTED 10943d: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 109440: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109443: 53 push %ebx <== NOT EXECUTED 109444: e8 b3 16 00 00 call 10aafc <_Objects_Get_information_id> <== NOT EXECUTED 109449: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10944b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10944e: 85 c0 test %eax,%eax <== NOT EXECUTED 109450: 74 2a je 10947c <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 109452: 51 push %ecx <== NOT EXECUTED 109453: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109456: 50 push %eax <== NOT EXECUTED 109457: 53 push %ebx <== NOT EXECUTED 109458: 56 push %esi <== NOT EXECUTED 109459: e8 36 18 00 00 call 10ac94 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10945e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109461: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109465: 75 15 jne 10947c <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 109467: 52 push %edx <== NOT EXECUTED 109468: 57 push %edi <== NOT EXECUTED 109469: 50 push %eax <== NOT EXECUTED 10946a: 56 push %esi <== NOT EXECUTED 10946b: e8 e0 19 00 00 call 10ae50 <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 109470: e8 bf 20 00 00 call 10b534 <_Thread_Enable_dispatch> <== NOT EXECUTED 109475: 31 c0 xor %eax,%eax <== NOT EXECUTED 109477: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10947a: eb 05 jmp 109481 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 10947c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109481: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109484: 5b pop %ebx <== NOT EXECUTED 109485: 5e pop %esi <== NOT EXECUTED 109486: 5f pop %edi <== NOT EXECUTED 109487: c9 leave <== NOT EXECUTED 109488: c3 ret <== NOT EXECUTED 0010957c : void rtems_panic( const char *printf_format, ... ) { 10957c: 55 push %ebp <== NOT EXECUTED 10957d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10957f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109582: 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); 109585: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109588: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10958d: e8 83 fe ff ff call 109415 <== NOT EXECUTED va_end(arglist); } 109592: c9 leave <== NOT EXECUTED 109593: 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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 1110e5: 40 inc %eax <== NOT EXECUTED 1110e6: a3 38 40 13 00 mov %eax,0x134038 <== 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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 1110f3: e8 54 3a 00 00 call 114b4c <_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 86 46 00 00 call 11578c <_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 6a 29 00 00 call 113aa4 <_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 88 3e 13 00 mov 0x133e88,%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 34 46 00 00 call 11578c <_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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 111187: e8 40 3e 00 00 call 114fcc <_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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 1111aa: e8 11 3a 00 00 call 114bc0 <_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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 1111b7: e8 a0 3c 00 00 call 114e5c <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1111bc: e8 cb 45 00 00 call 11578c <_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 bf 45 00 00 call 11578c <_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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 1111fa: e8 cd 3d 00 00 call 114fcc <_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 61 28 00 00 call 113a7c <_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 60 45 00 00 call 11578c <_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 55 45 00 00 call 11578c <_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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 111258: e8 b7 3e 00 00 call 115114 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11125d: 8b 04 85 8c 8d 12 00 mov 0x128d8c(,%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 6c 3e 13 00 push $0x133e6c <== NOT EXECUTED 11127f: e8 48 3d 00 00 call 114fcc <_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 95 27 00 00 call 113a58 <_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 c1 44 00 00 call 11578c <_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 b0 44 00 00 call 11578c <_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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 1107e5: 40 inc %eax <== NOT EXECUTED 1107e6: a3 38 40 13 00 mov %eax,0x134038 <== 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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 1107f3: e8 54 43 00 00 call 114b4c <_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 86 4f 00 00 call 11578c <_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 48 3e 13 00 mov 0x133e48,%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 54 4f 00 00 call 11578c <_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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 11085f: e8 68 47 00 00 call 114fcc <_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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 11087c: e8 3f 43 00 00 call 114bc0 <_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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 110889: e8 ce 45 00 00 call 114e5c <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 11088e: e8 f9 4e 00 00 call 11578c <_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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 1108c4: e8 03 47 00 00 call 114fcc <_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 9b 4e 00 00 call 11578c <_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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 11090f: e8 00 48 00 00 call 115114 <_Objects_Name_to_id_u32> <== NOT EXECUTED 110914: 8b 04 85 8c 8d 12 00 mov 0x128d8c(,%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 2c 3e 13 00 push $0x133e2c <== NOT EXECUTED 110944: e8 83 46 00 00 call 114fcc <_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 1b 4e 00 00 call 11578c <_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 ac 3e 13 00 push $0x133eac <== NOT EXECUTED 1112f7: e8 d0 3c 00 00 call 114fcc <_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 f8 40 13 00 cmp 0x1340f8,%eax <== NOT EXECUTED 111315: 74 0c je 111323 <== NOT EXECUTED _Thread_Enable_dispatch(); 111317: e8 70 44 00 00 call 11578c <_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 91 56 00 00 call 1169c0 <_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 51 44 00 00 call 11578c <_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 fc 1a 12 00 mov 0x121afc,%eax <== NOT EXECUTED 109ce5: 40 inc %eax <== NOT EXECUTED 109ce6: a3 fc 1a 12 00 mov %eax,0x121afc <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cee: 68 04 1a 12 00 push $0x121a04 <== NOT EXECUTED 109cf3: e8 84 1b 00 00 call 10b87c <_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 52 28 00 00 call 10c558 <_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 bc 1b 12 00 mov 0x121bbc,%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 20 1a 12 00 mov 0x121a20,%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 dd 27 00 00 call 10c558 <_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 ac 3e 13 00 push $0x133eac <== NOT EXECUTED 11142b: e8 9c 3b 00 00 call 114fcc <_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 ac 3e 13 00 push $0x133eac <== NOT EXECUTED 111448: e8 73 37 00 00 call 114bc0 <_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 68 55 00 00 call 1169c0 <_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 ac 3e 13 00 push $0x133eac <== NOT EXECUTED 111467: e8 f0 39 00 00 call 114e5c <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 11146c: e8 1b 43 00 00 call 11578c <_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 00129e2c : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 129e2c: 55 push %ebp <== NOT EXECUTED 129e2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129e2f: 57 push %edi <== NOT EXECUTED 129e30: 56 push %esi <== NOT EXECUTED 129e31: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 129e34: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 129e37: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 129e3c: 85 ff test %edi,%edi <== NOT EXECUTED 129e3e: 74 33 je 129e73 <== 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 129e40: 50 push %eax <== NOT EXECUTED 129e41: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 129e44: 50 push %eax <== NOT EXECUTED 129e45: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129e48: 68 78 b8 15 00 push $0x15b878 <== NOT EXECUTED 129e4d: e8 1e 53 fe ff call 10f170 <_Objects_Get> <== NOT EXECUTED 129e52: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 129e54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129e57: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 129e5c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 129e60: 75 11 jne 129e73 <== NOT EXECUTED case OBJECTS_LOCAL: *statistics = the_period->Statistics; 129e62: 8d 72 54 lea 0x54(%edx),%esi <== NOT EXECUTED 129e65: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 129e6a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 129e6c: e8 6f 5b fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 129e71: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 129e73: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129e76: 5e pop %esi <== NOT EXECUTED 129e77: 5f pop %edi <== NOT EXECUTED 129e78: c9 leave <== NOT EXECUTED 129e79: c3 ret <== NOT EXECUTED 00129e7c : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 129e7c: 55 push %ebp <== NOT EXECUTED 129e7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129e7f: 57 push %edi <== NOT EXECUTED 129e80: 56 push %esi <== NOT EXECUTED 129e81: 53 push %ebx <== NOT EXECUTED 129e82: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 129e85: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 129e88: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 129e8d: 85 f6 test %esi,%esi <== NOT EXECUTED 129e8f: 0f 84 91 00 00 00 je 129f26 <== NOT EXECUTED 129e95: 50 push %eax <== NOT EXECUTED 129e96: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 129e99: 50 push %eax <== NOT EXECUTED 129e9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129e9d: 68 78 b8 15 00 push $0x15b878 <== NOT EXECUTED 129ea2: e8 c9 52 fe ff call 10f170 <_Objects_Get> <== NOT EXECUTED 129ea7: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 129ea9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129eac: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 129eb1: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 129eb5: 75 6f jne 129f26 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 129eb7: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 129eba: 31 d2 xor %edx,%edx <== NOT EXECUTED 129ebc: 85 c0 test %eax,%eax <== NOT EXECUTED 129ebe: 74 03 je 129ec3 <== NOT EXECUTED 129ec0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 129ec3: 89 16 mov %edx,(%esi) <== NOT EXECUTED status->state = the_period->state; 129ec5: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 129ec8: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 129ecb: 85 c0 test %eax,%eax <== NOT EXECUTED 129ecd: 75 1e jne 129eed <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 129ecf: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 129ed6: 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; 129edd: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 129ee4: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED 129eeb: eb 32 jmp 129f1f <== 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 ); 129eed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129ef0: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 129ef3: 53 push %ebx <== NOT EXECUTED 129ef4: e8 67 80 ff ff call 121f60 <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 129ef9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129efc: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 129eff: 50 push %eax <== NOT EXECUTED 129f00: 53 push %ebx <== NOT EXECUTED 129f01: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 129f04: 50 push %eax <== NOT EXECUTED 129f05: e8 2e 66 fe ff call 110538 <_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( 129f0a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129f0d: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 129f10: 50 push %eax <== NOT EXECUTED 129f11: 53 push %ebx <== NOT EXECUTED 129f12: 68 94 ad 15 00 push $0x15ad94 <== NOT EXECUTED 129f17: e8 1c 66 fe ff call 110538 <_Timespec_Subtract> <== NOT EXECUTED 129f1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 129f1f: e8 bc 5a fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 129f24: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 129f26: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129f29: 5b pop %ebx <== NOT EXECUTED 129f2a: 5e pop %esi <== NOT EXECUTED 129f2b: 5f pop %edi <== NOT EXECUTED 129f2c: c9 leave <== NOT EXECUTED 129f2d: 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 04 1a 12 00 push $0x121a04 <== NOT EXECUTED 109d9e: e8 3d 21 00 00 call 10bee0 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109da3: 8b 04 85 10 ab 11 00 mov 0x11ab10(,%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 04 1a 12 00 push $0x121a04 <== NOT EXECUTED 109f6a: e8 29 1e 00 00 call 10bd98 <_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 bc 1b 12 00 cmp 0x121bbc,%eax <== NOT EXECUTED 109f87: 74 0f je 109f98 <== NOT EXECUTED _Thread_Enable_dispatch(); 109f89: e8 ca 25 00 00 call 10c558 <_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 a0 25 00 00 call 10c558 <_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 dc 1b 12 00 push $0x121bdc <== NOT EXECUTED 10a017: e8 98 34 00 00 call 10d4b4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a01c: e8 37 25 00 00 call 10c558 <_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 bc 1b 12 00 mov 0x121bbc,%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 1e 2d 00 00 call 10cd74 <_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 bc 1b 12 00 pushl 0x121bbc <== NOT EXECUTED 10a07a: e8 59 21 00 00 call 10c1d8 <_Thread_Clear_state> <== NOT EXECUTED 10a07f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 10a082: e8 d1 24 00 00 call 10c558 <_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 dc 1b 12 00 push $0x121bdc <== NOT EXECUTED 10a0ae: e8 01 34 00 00 call 10d4b4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a0b3: e8 a0 24 00 00 call 10c558 <_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 001215f8 : void rtems_rate_monotonic_report_statistics( void ) { 1215f8: 55 push %ebp <== NOT EXECUTED 1215f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1215fb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 1215fe: 68 e4 b1 10 00 push $0x10b1e4 <== NOT EXECUTED 121603: 6a 00 push $0x0 <== NOT EXECUTED 121605: e8 8e fe ff ff call 121498 <== NOT EXECUTED 12160a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 12160d: c9 leave <== NOT EXECUTED 12160e: c3 ret <== NOT EXECUTED 00121498 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 121498: 55 push %ebp <== NOT EXECUTED 121499: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12149b: 57 push %edi <== NOT EXECUTED 12149c: 56 push %esi <== NOT EXECUTED 12149d: 53 push %ebx <== NOT EXECUTED 12149e: 83 ec 6c sub $0x6c,%esp <== NOT EXECUTED 1214a1: 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 ) 1214a4: 85 f6 test %esi,%esi <== NOT EXECUTED 1214a6: 0f 84 44 01 00 00 je 1215f0 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 1214ac: 51 push %ecx <== NOT EXECUTED 1214ad: 51 push %ecx <== NOT EXECUTED 1214ae: 68 a4 df 13 00 push $0x13dfa4 <== NOT EXECUTED 1214b3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1214b6: ff d6 call *%esi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 1214b8: 58 pop %eax <== NOT EXECUTED 1214b9: 5a pop %edx <== NOT EXECUTED 1214ba: 68 c2 df 13 00 push $0x13dfc2 <== NOT EXECUTED 1214bf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1214c2: ff d6 call *%esi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 1214c4: 5f pop %edi <== NOT EXECUTED 1214c5: 58 pop %eax <== NOT EXECUTED 1214c6: 68 e4 df 13 00 push $0x13dfe4 <== NOT EXECUTED 1214cb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1214ce: ff d6 call *%esi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 1214d0: 59 pop %ecx <== NOT EXECUTED 1214d1: 5b pop %ebx <== NOT EXECUTED 1214d2: 68 07 e0 13 00 push $0x13e007 <== NOT EXECUTED 1214d7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1214da: ff d6 call *%esi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 1214dc: 58 pop %eax <== NOT EXECUTED 1214dd: 5a pop %edx <== NOT EXECUTED 1214de: 68 52 e0 13 00 push $0x13e052 <== NOT EXECUTED 1214e3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1214e6: 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 ; 1214e8: 8b 3d 80 b8 15 00 mov 0x15b880,%edi <== NOT EXECUTED 1214ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1214f1: e9 ee 00 00 00 jmp 1215e4 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 1214f6: 50 push %eax <== NOT EXECUTED 1214f7: 50 push %eax <== NOT EXECUTED 1214f8: 8d 45 94 lea -0x6c(%ebp),%eax <== NOT EXECUTED 1214fb: 50 push %eax <== NOT EXECUTED 1214fc: 57 push %edi <== NOT EXECUTED 1214fd: e8 2a 89 00 00 call 129e2c <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 121502: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121505: 85 c0 test %eax,%eax <== NOT EXECUTED 121507: 0f 85 d6 00 00 00 jne 1215e3 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 12150d: 50 push %eax <== NOT EXECUTED 12150e: 50 push %eax <== NOT EXECUTED 12150f: 8d 55 cc lea -0x34(%ebp),%edx <== NOT EXECUTED 121512: 52 push %edx <== NOT EXECUTED 121513: 57 push %edi <== NOT EXECUTED 121514: e8 63 89 00 00 call 129e7c <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 121519: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 12151d: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED 121520: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121523: 85 d2 test %edx,%edx <== NOT EXECUTED 121525: 74 10 je 121537 <== NOT EXECUTED rtems_object_get_name( the_status.owner, sizeof(name), name ); 121527: 50 push %eax <== NOT EXECUTED 121528: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 12152b: 50 push %eax <== NOT EXECUTED 12152c: 6a 05 push $0x5 <== NOT EXECUTED 12152e: 52 push %edx <== NOT EXECUTED 12152f: e8 2c c1 fe ff call 10d660 <== NOT EXECUTED 121534: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 121537: 53 push %ebx <== NOT EXECUTED 121538: 53 push %ebx <== NOT EXECUTED 121539: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 12153c: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 12153f: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 121542: 50 push %eax <== NOT EXECUTED 121543: 57 push %edi <== NOT EXECUTED 121544: 68 9e e0 13 00 push $0x13e09e <== NOT EXECUTED 121549: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12154c: ff d6 call *%esi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 12154e: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED 121551: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 121554: 85 c0 test %eax,%eax <== NOT EXECUTED 121556: 75 11 jne 121569 <== NOT EXECUTED (*print)( context, "\n" ); 121558: 51 push %ecx <== NOT EXECUTED 121559: 51 push %ecx <== NOT EXECUTED 12155a: 68 d5 e3 13 00 push $0x13e3d5 <== NOT EXECUTED 12155f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121562: ff d6 call *%esi <== NOT EXECUTED 121564: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121567: eb 7a jmp 1215e3 <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 121569: 52 push %edx <== NOT EXECUTED 12156a: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 12156d: 52 push %edx <== NOT EXECUTED 12156e: 50 push %eax <== NOT EXECUTED 12156f: 8d 45 ac lea -0x54(%ebp),%eax <== NOT EXECUTED 121572: 50 push %eax <== NOT EXECUTED 121573: e8 10 13 00 00 call 122888 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 121578: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 12157b: bb e8 03 00 00 mov $0x3e8,%ebx <== NOT EXECUTED 121580: 99 cltd <== NOT EXECUTED 121581: f7 fb idiv %ebx <== NOT EXECUTED 121583: 50 push %eax <== NOT EXECUTED 121584: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 121587: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 12158a: 99 cltd <== NOT EXECUTED 12158b: f7 fb idiv %ebx <== NOT EXECUTED 12158d: 50 push %eax <== NOT EXECUTED 12158e: ff 75 a4 pushl -0x5c(%ebp) <== NOT EXECUTED 121591: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 121594: 99 cltd <== NOT EXECUTED 121595: f7 fb idiv %ebx <== NOT EXECUTED 121597: 50 push %eax <== NOT EXECUTED 121598: ff 75 9c pushl -0x64(%ebp) <== NOT EXECUTED 12159b: 68 b5 e0 13 00 push $0x13e0b5 <== NOT EXECUTED 1215a0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1215a3: 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( 1215a5: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 1215a8: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1215ab: 50 push %eax <== NOT EXECUTED 1215ac: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 1215af: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 1215b2: 50 push %eax <== NOT EXECUTED 1215b3: e8 d0 12 00 00 call 122888 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 1215b8: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1215bb: 99 cltd <== NOT EXECUTED 1215bc: f7 fb idiv %ebx <== NOT EXECUTED 1215be: 50 push %eax <== NOT EXECUTED 1215bf: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1215c2: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 1215c5: 99 cltd <== NOT EXECUTED 1215c6: f7 fb idiv %ebx <== NOT EXECUTED 1215c8: 50 push %eax <== NOT EXECUTED 1215c9: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 1215cc: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED 1215cf: 99 cltd <== NOT EXECUTED 1215d0: f7 fb idiv %ebx <== NOT EXECUTED 1215d2: 50 push %eax <== NOT EXECUTED 1215d3: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 1215d6: 68 d4 e0 13 00 push $0x13e0d4 <== NOT EXECUTED 1215db: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1215de: ff d6 call *%esi <== NOT EXECUTED 1215e0: 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++ ) { 1215e3: 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 ; 1215e4: 3b 3d 84 b8 15 00 cmp 0x15b884,%edi <== NOT EXECUTED 1215ea: 0f 86 06 ff ff ff jbe 1214f6 <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 1215f0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1215f3: 5b pop %ebx <== NOT EXECUTED 1215f4: 5e pop %esi <== NOT EXECUTED 1215f5: 5f pop %edi <== NOT EXECUTED 1215f6: c9 leave <== NOT EXECUTED 1215f7: c3 ret <== NOT EXECUTED 00121610 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 121610: 55 push %ebp <== NOT EXECUTED 121611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121613: 53 push %ebx <== NOT EXECUTED 121614: 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 121617: a1 cc ac 15 00 mov 0x15accc,%eax <== NOT EXECUTED 12161c: 40 inc %eax <== NOT EXECUTED 12161d: a3 cc ac 15 00 mov %eax,0x15accc <== 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 ; 121622: 8b 1d 80 b8 15 00 mov 0x15b880,%ebx <== NOT EXECUTED 121628: eb 0d jmp 121637 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 12162a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12162d: 53 push %ebx <== NOT EXECUTED 12162e: e8 15 00 00 00 call 121648 <== 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++ ) { 121633: 43 inc %ebx <== NOT EXECUTED 121634: 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 ; 121637: 3b 1d 84 b8 15 00 cmp 0x15b884,%ebx <== NOT EXECUTED 12163d: 76 eb jbe 12162a <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 12163f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 121642: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 121643: e9 98 e3 fe ff jmp 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 00121648 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 121648: 55 push %ebp <== NOT EXECUTED 121649: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12164b: 57 push %edi <== NOT EXECUTED 12164c: 56 push %esi <== NOT EXECUTED 12164d: 53 push %ebx <== NOT EXECUTED 12164e: 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 121651: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 121654: 50 push %eax <== NOT EXECUTED 121655: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121658: 68 78 b8 15 00 push $0x15b878 <== NOT EXECUTED 12165d: e8 0e db fe ff call 10f170 <_Objects_Get> <== NOT EXECUTED 121662: 89 c6 mov %eax,%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 121664: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121667: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 12166a: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 12166f: 85 db test %ebx,%ebx <== NOT EXECUTED 121671: 75 2f jne 1216a2 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 121673: 8d 78 54 lea 0x54(%eax),%edi <== NOT EXECUTED 121676: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 12167b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12167d: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 12167f: c7 46 5c ff ff ff 7f movl $0x7fffffff,0x5c(%esi) <== NOT EXECUTED 121686: c7 46 60 ff ff ff 7f movl $0x7fffffff,0x60(%esi) <== NOT EXECUTED 12168d: c7 46 74 ff ff ff 7f movl $0x7fffffff,0x74(%esi) <== NOT EXECUTED 121694: c7 46 78 ff ff ff 7f movl $0x7fffffff,0x78(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12169b: e8 40 e3 fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1216a0: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1216a2: 89 d0 mov %edx,%eax <== NOT EXECUTED 1216a4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1216a7: 5b pop %ebx <== NOT EXECUTED 1216a8: 5e pop %esi <== NOT EXECUTED 1216a9: 5f pop %edi <== NOT EXECUTED 1216aa: c9 leave <== NOT EXECUTED 1216ab: 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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 11194a: e8 95 20 00 00 call 1139e4 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11194f: c7 04 24 ec 3e 13 00 movl $0x133eec,(%esp) <== NOT EXECUTED 111956: e8 f1 31 00 00 call 114b4c <_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 15 2d 00 00 call 114690 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 11198d: e8 ca 34 00 00 call 114e5c <_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 47 44 00 00 call 115e10 <_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 08 3f 13 00 mov 0x133f08,%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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 1119f0: e8 37 20 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111a1a: e8 c5 1f 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111a2e: e8 5d 35 00 00 call 114f90 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111a63: e8 58 31 00 00 call 114bc0 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111a70: e8 e7 33 00 00 call 114e5c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111a83: e8 a4 1f 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111ab6: e8 29 1f 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111aca: e8 c1 34 00 00 call 114f90 <_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 ec 28 00 00 call 1143e0 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111b27: e8 00 1f 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111b59: e8 86 1e 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111b6d: e8 1e 34 00 00 call 114f90 <_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 22 2a 00 00 call 1145d0 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111bbc: e8 6b 1e 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111bed: e8 f2 1d 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111c01: e8 8a 33 00 00 call 114f90 <_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 e3 29 00 00 call 114610 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111c43: e8 e4 1d 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111c8d: e8 52 1d 00 00 call 1139e4 <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 111c92: 8b 3d f8 40 13 00 mov 0x1340f8,%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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111ca7: e8 e4 32 00 00 call 114f90 <_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 8d 26 00 00 call 114374 <_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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 111d0a: 40 inc %eax <== NOT EXECUTED 111d0b: a3 38 40 13 00 mov %eax,0x134038 <== 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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111d19: e8 0e 1d 00 00 call 113a2c <_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 e0 5e 11 00 push $0x115ee0 <== NOT EXECUTED 111d45: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 111d48: 50 push %eax <== NOT EXECUTED 111d49: e8 8e 3e 00 00 call 115bdc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 111d4e: e8 39 3a 00 00 call 11578c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111d61: e8 c6 1c 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111d93: e8 4c 1c 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111da7: e8 e4 31 00 00 call 114f90 <_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 75 2c 00 00 call 114a48 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111de6: e8 41 1c 00 00 call 113a2c <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111e16: e8 f9 32 00 00 call 115114 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111e1b: 8b 04 85 8c 8d 12 00 mov 0x128d8c(,%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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111e41: e8 9e 1b 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111e55: e8 36 31 00 00 call 114f90 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111e7e: e8 a9 1b 00 00 call 113a2c <_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 b9 29 00 00 call 114858 <_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 48 68 00 00 call 118704 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111ecc: e8 5b 1b 00 00 call 113a2c <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111f02: e8 dd 1a 00 00 call 1139e4 <_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 ec 3e 13 00 push $0x133eec <== NOT EXECUTED 111f16: e8 75 30 00 00 call 114f90 <_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 22 25 00 00 call 114468 <_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 a6 67 00 00 call 118704 <_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 f0 40 13 00 pushl 0x1340f0 <== NOT EXECUTED 111f6b: e8 bc 1a 00 00 call 113a2c <_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 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 108f8b: 40 inc %eax <== NOT EXECUTED 108f8c: a3 78 d6 11 00 mov %eax,0x11d678 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 108f91: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f94: 68 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 108f99: e8 be 12 00 00 call 10a25c <_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 b4 1e 00 00 call 10ae60 <_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 ed 0b 00 00 call 109c1c <_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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 10903f: e8 28 15 00 00 call 10a56c <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 109044: e8 17 1e 00 00 call 10ae60 <_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 14 0e 00 00 call 109e98 <_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 dc d5 11 00 mov 0x11d5dc,%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 bb 1d 00 00 call 10ae60 <_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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 1090cb: e8 d0 15 00 00 call 10a6a0 <_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 68 1d 00 00 call 10ae60 <_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 03 0b 00 00 call 109c10 <_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 6f 0d 00 00 call 109e8c <_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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 109125: e8 a6 11 00 00 call 10a2d0 <_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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 109132: e8 35 14 00 00 call 10a56c <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 109137: e8 24 1d 00 00 call 10ae60 <_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 0012170c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 12170c: 55 push %ebp <== NOT EXECUTED 12170d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12170f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 121712: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 121715: 50 push %eax <== NOT EXECUTED 121716: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121719: 68 14 ac 15 00 push $0x15ac14 <== NOT EXECUTED 12171e: e8 4d da fe ff call 10f170 <_Objects_Get> <== NOT EXECUTED 121723: 89 c2 mov %eax,%edx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 121725: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121728: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 12172d: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 121731: 75 2b jne 12175e <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 121733: f6 42 10 30 testb $0x30,0x10(%edx) <== NOT EXECUTED 121737: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 12173a: 74 0d je 121749 <== NOT EXECUTED _CORE_mutex_Flush( 12173c: 51 push %ecx <== NOT EXECUTED 12173d: 6a 01 push $0x1 <== NOT EXECUTED 12173f: 6a 00 push $0x0 <== NOT EXECUTED 121741: 50 push %eax <== NOT EXECUTED 121742: e8 69 ce fe ff call 10e5b0 <_CORE_mutex_Flush> <== NOT EXECUTED 121747: eb 0b jmp 121754 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 121749: 52 push %edx <== NOT EXECUTED 12174a: 6a 01 push $0x1 <== NOT EXECUTED 12174c: 6a 00 push $0x0 <== NOT EXECUTED 12174e: 50 push %eax <== NOT EXECUTED 12174f: e8 d8 d0 fe ff call 10e82c <_CORE_semaphore_Flush> <== NOT EXECUTED 121754: 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(); 121757: e8 84 e2 fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 12175c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12175e: c9 leave <== NOT EXECUTED 12175f: 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 2c 3f 13 00 push $0x133f2c <== NOT EXECUTED 112218: e8 f7 2e 00 00 call 115114 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11221d: 8b 04 85 8c 8d 12 00 mov 0x128d8c(,%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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 109165: e8 ea 14 00 00 call 10a654 <_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 6a 0b 00 00 call 109d08 <_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 38 d7 11 00 mov 0x11d738,%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 38 d7 11 00 mov 0x11d738,%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 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 1091e4: 40 inc %eax <== NOT EXECUTED 1091e5: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 b4 b5 10 00 push $0x10b5b4 <== NOT EXECUTED 109202: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109205: 50 push %eax <== NOT EXECUTED 109206: e8 a5 20 00 00 call 10b2b0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10920b: e8 50 1c 00 00 call 10ae60 <_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 38 d7 11 00 mov 0x11d738,%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 c0 d5 11 00 push $0x11d5c0 <== NOT EXECUTED 109244: e8 57 14 00 00 call 10a6a0 <_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 2c 0b 00 00 call 109d98 <_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 ed 1b 00 00 call 10ae60 <_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 51 0c 00 00 call 109ed8 <_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 d2 1b 00 00 call 10ae60 <_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 001157bc : */ void rtems_shutdown_executive( uint32_t result ) { 1157bc: 55 push %ebp <== NOT EXECUTED 1157bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1157bf: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 1157c2: 83 3d 18 d8 11 00 04 cmpl $0x4,0x11d818 <== NOT EXECUTED 1157c9: 74 1d je 1157e8 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 1157cb: c7 05 18 d8 11 00 04 movl $0x4,0x11d818 <== NOT EXECUTED 1157d2: 00 00 00 <== NOT EXECUTED #endif } /** * This routine sets the current system state to that specified by * the called. 1157d5: 50 push %eax <== NOT EXECUTED 1157d6: 50 push %eax <== NOT EXECUTED 1157d7: 68 60 d6 11 00 push $0x11d660 <== NOT EXECUTED 1157dc: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 1157df: 50 push %eax <== NOT EXECUTED 1157e0: e8 ab 66 ff ff call 10be90 <_CPU_Context_switch> <== NOT EXECUTED 1157e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 1157e8: c9 leave <== NOT EXECUTED 1157e9: 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 84 11 12 00 mov 0x121184,%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 c4 10 12 00 mov 0x1210c4,%eax <== NOT EXECUTED 109edd: 40 inc %eax <== NOT EXECUTED 109ede: a3 c4 10 12 00 mov %eax,0x1210c4 <== 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 8e 1e 00 00 call 10bdac <_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 eb 33 00 00 call 1157ac <_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 d4 40 13 00 mov 0x1340d4,%eax <== NOT EXECUTED 1123f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1123f6: 74 19 je 112411 <== NOT EXECUTED 1123f8: 3b 0d f8 40 13 00 cmp 0x1340f8,%ecx <== NOT EXECUTED 1123fe: 75 11 jne 112411 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 112400: c6 05 8c 41 13 00 01 movb $0x1,0x13418c <== 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 76 33 00 00 call 11578c <_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 6d 33 00 00 call 11578c <_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 48 ab 15 00 mov $0x15ab48,%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 8c ad 15 00 mov 0x15ad8c,%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 50 7a 14 00 00 cmpl $0x0,0x147a50 <== 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 48 ab 15 00 push $0x15ab48 <== NOT EXECUTED 1087ee: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED 1087f1: 50 push %eax <== NOT EXECUTED 1087f2: e8 ad 4d 02 00 call 12d5a4 <== 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 8c ad 15 00 pushl 0x15ad8c <== 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 54 7a 14 00 mov %ebx,0x147a54 <== NOT EXECUTED print_handler = print; 1086e7: 89 35 58 7a 14 00 mov %esi,0x147a58 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1086ed: 51 push %ecx <== NOT EXECUTED 1086ee: 51 push %ecx <== NOT EXECUTED 1086ef: 68 5d b6 13 00 push $0x13b65d <== 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 74 b6 13 00 push $0x13b674 <== 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 ef 64 00 00 call 10ebfc <== 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 54 7a 14 00 00 movl $0x0,0x147a54 <== NOT EXECUTED 108720: 00 00 00 <== NOT EXECUTED print_handler = NULL; 108723: c7 05 58 7a 14 00 00 movl $0x0,0x147a58 <== 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 48 ab 15 00 push $0x15ab48 <== NOT EXECUTED 108851: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED 108854: 50 push %eax <== NOT EXECUTED 108855: e8 4a 4d 02 00 call 12d5a4 <== 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 00109400 : const char * rtems_status_text( rtems_status_code status ) { 109400: 55 push %ebp <== NOT EXECUTED 109401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109403: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 109406: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109409: 68 2c 08 12 00 push $0x12082c <== NOT EXECUTED 10940e: e8 1d 86 00 00 call 111a30 <== NOT EXECUTED } 109413: c9 leave <== NOT EXECUTED 109414: 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 64 92 11 00 movzbl 0x119264,%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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10931f: e8 28 07 00 00 call 109a4c <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109324: c7 04 24 00 d6 11 00 movl $0x11d600,(%esp) <== NOT EXECUTED 10932b: e8 2c 0f 00 00 call 10a25c <_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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 109342: e8 4d 07 00 00 call 109a94 <_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 00 d6 11 00 push $0x11d600 <== NOT EXECUTED 109384: e8 6f 1b 00 00 call 10aef8 <_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 45 12 00 00 call 10a5e0 <_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 c8 11 00 00 call 10a56c <_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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 1093ab: e8 e4 06 00 00 call 109a94 <_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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 1093dc: e8 b3 06 00 00 call 109a94 <_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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 1093fd: e8 4a 06 00 00 call 109a4c <_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 70 1a 00 00 call 10ae80 <_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 ba 11 00 00 call 10a5e0 <_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 39 17 00 00 call 10ab68 <_Thread_Close> <== NOT EXECUTED 10942f: 58 pop %eax <== NOT EXECUTED 109430: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 109433: e8 a8 11 00 00 call 10a5e0 <_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 2b 11 00 00 call 10a56c <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 109441: 58 pop %eax <== NOT EXECUTED 109442: ff 35 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 109448: e8 47 06 00 00 call 109a94 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10944d: e8 0e 1a 00 00 call 10ae60 <_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 30 d7 11 00 pushl 0x11d730 <== NOT EXECUTED 10945f: e8 30 06 00 00 call 109a94 <_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 0010a9f8 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10a9f8: 55 push %ebp <== NOT EXECUTED 10a9f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a9fb: 56 push %esi <== NOT EXECUTED 10a9fc: 53 push %ebx <== NOT EXECUTED 10a9fd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10aa00: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aa03: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10aa06: 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() ) 10aa09: a1 24 18 12 00 mov 0x121824,%eax <== NOT EXECUTED 10aa0e: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10aa11: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10aa16: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10aa1a: 74 61 je 10aa7d <== NOT EXECUTED return RTEMS_NOT_CONFIGURED; if ( !note ) 10aa1c: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10aa21: 85 f6 test %esi,%esi <== NOT EXECUTED 10aa23: 74 58 je 10aa7d <== 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 ) 10aa25: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10aa2a: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10aa2d: 77 4e ja 10aa7d <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10aa2f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa31: 74 0a je 10aa3d <== NOT EXECUTED 10aa33: a1 4c 18 12 00 mov 0x12184c,%eax <== NOT EXECUTED 10aa38: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10aa3b: 75 13 jne 10aa50 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa3d: a1 4c 18 12 00 mov 0x12184c,%eax <== NOT EXECUTED 10aa42: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa48: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa4c: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10aa4e: eb 2b jmp 10aa7b <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10aa50: 50 push %eax <== NOT EXECUTED 10aa51: 50 push %eax <== NOT EXECUTED 10aa52: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10aa55: 50 push %eax <== NOT EXECUTED 10aa56: 51 push %ecx <== NOT EXECUTED 10aa57: e8 d8 1c 00 00 call 10c734 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10aa5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa5f: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10aa64: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10aa68: 75 13 jne 10aa7d <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa6a: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa70: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa74: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aa76: e8 99 1c 00 00 call 10c714 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aa7b: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10aa7d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10aa7f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aa82: 5b pop %ebx <== NOT EXECUTED 10aa83: 5e pop %esi <== NOT EXECUTED 10aa84: c9 leave <== NOT EXECUTED 10aa85: 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 38 d7 11 00 mov 0x11d738,%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 00 d6 11 00 push $0x11d600 <== NOT EXECUTED 1094a5: e8 3e 13 00 00 call 10a7e8 <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 1094aa: 8b 04 85 68 72 11 00 mov 0x117268(,%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 46 1a 00 00 call 10b418 <_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 0b 1a 00 00 call 10b3f8 <_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 02 1a 00 00 call 10b3f8 <_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 0010ec64 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10ec64: 55 push %ebp <== NOT EXECUTED 10ec65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec67: 57 push %edi <== NOT EXECUTED 10ec68: 56 push %esi <== NOT EXECUTED 10ec69: 53 push %ebx <== NOT EXECUTED 10ec6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ec6d: 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 ) 10ec70: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10ec75: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10ec79: 0f 84 04 01 00 00 je 10ed83 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10ec7f: a1 38 d7 11 00 mov 0x11d738,%eax <== NOT EXECUTED 10ec84: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10ec87: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 10ec8d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10ec90: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 10ec94: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10ec96: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10ec9c: 83 78 7c 00 cmpl $0x0,0x7c(%eax) <== NOT EXECUTED 10eca0: 74 06 je 10eca8 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10eca2: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10eca8: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10ecab: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 10ecaf: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10ecb1: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 10ecb7: e8 af d3 ff ff call 10c06b <_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; 10ecbc: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10ecbe: 09 f3 or %esi,%ebx <== NOT EXECUTED 10ecc0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ecc3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10ecc5: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 10eccc: 74 11 je 10ecdf <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10ecce: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ecd0: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10ecd3: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10ecd6: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10ecd9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10ecdc: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 10ecdf: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 10ece6: 74 26 je 10ed0e <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 10ece8: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 10ecee: 74 14 je 10ed04 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10ecf0: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10ecf3: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ecfa: a1 44 d6 11 00 mov 0x11d644,%eax <== NOT EXECUTED 10ecff: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ed02: eb 0a jmp 10ed0e <== NOT EXECUTED } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10ed04: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ed07: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10ed0e: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10ed12: 74 0c je 10ed20 <== 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 10ed14: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10ed1a: 74 03 je 10ed1f <== NOT EXECUTED 10ed1c: fa cli <== NOT EXECUTED 10ed1d: eb 01 jmp 10ed20 <== NOT EXECUTED 10ed1f: fb sti <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10ed20: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 10ed27: 74 3b je 10ed64 <== NOT EXECUTED 10ed29: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 10ed2c: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 10ed2f: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ed31: 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 ) { 10ed34: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10ed37: 3a 42 08 cmp 0x8(%edx),%al <== NOT EXECUTED 10ed3a: 74 28 je 10ed64 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 10ed3c: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10ed3f: 9c pushf <== NOT EXECUTED 10ed40: fa cli <== NOT EXECUTED 10ed41: 59 pop %ecx <== NOT EXECUTED /** 10ed42: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10ed45: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10ed48: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10ed4b: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 10ed4e: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 10ed51: 51 push %ecx <== NOT EXECUTED 10ed52: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10ed53: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10ed57: 74 0b je 10ed64 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10ed59: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ed5c: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10ed60: b3 01 mov $0x1,%bl <== NOT EXECUTED 10ed62: eb 02 jmp 10ed66 <== NOT EXECUTED 10ed64: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 10ed66: 83 3d 18 d8 11 00 03 cmpl $0x3,0x11d818 <== NOT EXECUTED 10ed6d: 75 12 jne 10ed81 <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10ed6f: e8 58 01 00 00 call 10eecc <_Thread_Evaluate_mode> <== NOT EXECUTED 10ed74: 84 c0 test %al,%al <== NOT EXECUTED 10ed76: 75 04 jne 10ed7c <== NOT EXECUTED 10ed78: 84 db test %bl,%bl <== NOT EXECUTED 10ed7a: 74 05 je 10ed81 <== NOT EXECUTED _Thread_Dispatch(); 10ed7c: e8 9b bf ff ff call 10ad1c <_Thread_Dispatch> <== NOT EXECUTED 10ed81: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10ed83: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ed86: 5b pop %ebx <== NOT EXECUTED 10ed87: 5e pop %esi <== NOT EXECUTED 10ed88: 5f pop %edi <== NOT EXECUTED 10ed89: c9 leave <== NOT EXECUTED 10ed8a: 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 3a 1a 00 00 call 10b81c <_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 86 21 00 00 call 10bf84 <_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 f2 19 00 00 call 10b7fc <_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 e9 19 00 00 call 10b7fc <_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 96 1c 00 00 call 10c22c <_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 de 23 00 00 call 10c994 <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a5b6: e8 25 1c 00 00 call 10c1e0 <_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 19 1c 00 00 call 10c1e0 <_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 001218f8 : #include #include rtems_id rtems_task_self(void) { 1218f8: 55 push %ebp <== NOT EXECUTED 1218f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1218fb: a1 8c ad 15 00 mov 0x15ad8c,%eax <== NOT EXECUTED 121900: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 121903: c9 leave <== NOT EXECUTED 121904: c3 ret <== NOT EXECUTED 0010ab5c : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10ab5c: 55 push %ebp <== NOT EXECUTED 10ab5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab5f: 56 push %esi <== NOT EXECUTED 10ab60: 53 push %ebx <== NOT EXECUTED 10ab61: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ab64: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ab67: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ab6a: 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() ) 10ab6d: a1 24 18 12 00 mov 0x121824,%eax <== NOT EXECUTED 10ab72: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10ab75: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10ab7a: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10ab7e: 74 54 je 10abd4 <== 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 ) 10ab80: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10ab85: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10ab88: 77 4a ja 10abd4 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ab8a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab8c: 74 0a je 10ab98 <== NOT EXECUTED 10ab8e: a1 4c 18 12 00 mov 0x12184c,%eax <== NOT EXECUTED 10ab93: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10ab96: 75 11 jne 10aba9 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10ab98: a1 4c 18 12 00 mov 0x12184c,%eax <== NOT EXECUTED 10ab9d: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aba3: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED 10aba7: eb 29 jmp 10abd2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10aba9: 50 push %eax <== NOT EXECUTED 10abaa: 50 push %eax <== NOT EXECUTED 10abab: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abae: 50 push %eax <== NOT EXECUTED 10abaf: 51 push %ecx <== NOT EXECUTED 10abb0: e8 7f 1b 00 00 call 10c734 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10abb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abb8: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10abbd: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10abc1: 75 11 jne 10abd4 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10abc3: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10abc9: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10abcd: e8 42 1b 00 00 call 10c714 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abd2: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10abd4: 89 d0 mov %edx,%eax <== NOT EXECUTED 10abd6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10abd9: 5b pop %ebx <== NOT EXECUTED 10abda: 5e pop %esi <== NOT EXECUTED 10abdb: c9 leave <== NOT EXECUTED 10abdc: c3 ret <== NOT EXECUTED 0010ca04 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10ca04: 55 push %ebp <== NOT EXECUTED 10ca05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca07: 56 push %esi <== NOT EXECUTED 10ca08: 53 push %ebx <== NOT EXECUTED 10ca09: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca0c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ca0f: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10ca12: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca14: 74 10 je 10ca26 <== NOT EXECUTED 10ca16: 0f b6 05 44 44 12 00 movzbl 0x124444,%eax <== NOT EXECUTED 10ca1d: ba 13 00 00 00 mov $0x13,%edx <== NOT EXECUTED 10ca22: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ca24: 77 52 ja 10ca78 <== NOT EXECUTED !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10ca26: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10ca2b: 85 f6 test %esi,%esi <== NOT EXECUTED 10ca2d: 74 49 je 10ca78 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10ca2f: 52 push %edx <== NOT EXECUTED 10ca30: 52 push %edx <== NOT EXECUTED 10ca31: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10ca34: 50 push %eax <== NOT EXECUTED 10ca35: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca38: e8 d7 1a 00 00 call 10e514 <_Thread_Get> <== NOT EXECUTED 10ca3d: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10ca3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca42: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10ca47: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10ca4b: 75 2b jne 10ca78 <== NOT EXECUTED case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10ca4d: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ca50: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10ca52: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca54: 74 1b je 10ca71 <== NOT EXECUTED the_thread->real_priority = new_priority; 10ca56: 89 59 18 mov %ebx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10ca59: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 10ca5d: 74 05 je 10ca64 <== NOT EXECUTED 10ca5f: 39 59 14 cmp %ebx,0x14(%ecx) <== NOT EXECUTED 10ca62: 76 0d jbe 10ca71 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10ca64: 50 push %eax <== NOT EXECUTED 10ca65: 6a 00 push $0x0 <== NOT EXECUTED 10ca67: 53 push %ebx <== NOT EXECUTED 10ca68: 51 push %ecx <== NOT EXECUTED 10ca69: e8 ba 15 00 00 call 10e028 <_Thread_Change_priority> <== NOT EXECUTED 10ca6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10ca71: e8 52 1a 00 00 call 10e4c8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca76: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ca78: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ca7a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca7d: 5b pop %ebx <== NOT EXECUTED 10ca7e: 5e pop %esi <== NOT EXECUTED 10ca7f: c9 leave <== NOT EXECUTED 10ca80: 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 2f 19 00 00 call 10ae80 <_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 f6 22 00 00 call 10b868 <_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 e2 18 00 00 call 10ae60 <_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 d9 18 00 00 call 10ae60 <_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 e6 1b 00 00 call 10c22c <_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 af 26 00 00 call 10cd14 <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a665: e8 76 1b 00 00 call 10c1e0 <_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 6a 1b 00 00 call 10c1e0 <_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 00121af0 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 121af0: 55 push %ebp <== NOT EXECUTED 121af1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121af3: 57 push %edi <== NOT EXECUTED 121af4: 56 push %esi <== NOT EXECUTED 121af5: 53 push %ebx <== NOT EXECUTED 121af6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 121af9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 121afc: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 121aff: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121b04: 85 f6 test %esi,%esi <== NOT EXECUTED 121b06: 74 75 je 121b7d <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 121b08: 50 push %eax <== NOT EXECUTED 121b09: 50 push %eax <== NOT EXECUTED 121b0a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 121b0d: 50 push %eax <== NOT EXECUTED 121b0e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121b11: e8 ea de fe ff call 10fa00 <_Thread_Get> <== NOT EXECUTED 121b16: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 121b18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121b1b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 121b20: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 121b24: 75 57 jne 121b7d <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 121b26: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 121b2c: eb 0c jmp 121b3a <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 121b2e: 39 70 04 cmp %esi,0x4(%eax) <== NOT EXECUTED 121b31: 75 05 jne 121b38 <== NOT EXECUTED tvp->dtor = dtor; 121b33: 89 78 10 mov %edi,0x10(%eax) <== NOT EXECUTED 121b36: eb 3e jmp 121b76 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 121b38: 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) { 121b3a: 85 c0 test %eax,%eax <== NOT EXECUTED 121b3c: 75 f0 jne 121b2e <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 121b3e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121b41: 6a 14 push $0x14 <== NOT EXECUTED 121b43: e8 35 ee fe ff call 11097d <_Workspace_Allocate> <== NOT EXECUTED 121b48: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 121b4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121b4d: 85 c0 test %eax,%eax <== NOT EXECUTED 121b4f: 75 0c jne 121b5d <== NOT EXECUTED _Thread_Enable_dispatch(); 121b51: e8 8a de fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 121b56: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 121b5b: eb 20 jmp 121b7d <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 121b5d: 8b 06 mov (%esi),%eax <== NOT EXECUTED 121b5f: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 121b62: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 121b65: 89 7a 10 mov %edi,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 121b68: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 121b6e: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 121b70: 89 93 04 01 00 00 mov %edx,0x104(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 121b76: e8 65 de fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 121b7b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121b7d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121b80: 5b pop %ebx <== NOT EXECUTED 121b81: 5e pop %esi <== NOT EXECUTED 121b82: 5f pop %edi <== NOT EXECUTED 121b83: c9 leave <== NOT EXECUTED 121b84: c3 ret <== NOT EXECUTED 00121b88 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 121b88: 55 push %ebp <== NOT EXECUTED 121b89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121b8b: 56 push %esi <== NOT EXECUTED 121b8c: 53 push %ebx <== NOT EXECUTED 121b8d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121b90: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 121b93: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121b98: 85 f6 test %esi,%esi <== NOT EXECUTED 121b9a: 74 64 je 121c00 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 121b9c: 52 push %edx <== NOT EXECUTED 121b9d: 52 push %edx <== NOT EXECUTED 121b9e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 121ba1: 50 push %eax <== NOT EXECUTED 121ba2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121ba5: e8 56 de fe ff call 10fa00 <_Thread_Get> <== NOT EXECUTED 121baa: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 121bac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121baf: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 121bb4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 121bb8: 75 46 jne 121c00 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 121bba: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx <== NOT EXECUTED 121bc0: 31 c0 xor %eax,%eax <== NOT EXECUTED 121bc2: eb 2e jmp 121bf2 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 121bc4: 39 72 04 cmp %esi,0x4(%edx) <== NOT EXECUTED 121bc7: 75 25 jne 121bee <== NOT EXECUTED if (prev) 121bc9: 85 c0 test %eax,%eax <== NOT EXECUTED 121bcb: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 121bcd: 74 04 je 121bd3 <== NOT EXECUTED prev->next = tvp->next; 121bcf: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 121bd1: eb 06 jmp 121bd9 <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 121bd3: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx) <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 121bd9: 50 push %eax <== NOT EXECUTED 121bda: 50 push %eax <== NOT EXECUTED 121bdb: 52 push %edx <== NOT EXECUTED 121bdc: 53 push %ebx <== NOT EXECUTED 121bdd: e8 8e 00 00 00 call 121c70 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 121be2: e8 f9 dd fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 121be7: 31 c0 xor %eax,%eax <== NOT EXECUTED 121be9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121bec: eb 12 jmp 121c00 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 121bee: 89 d0 mov %edx,%eax <== NOT EXECUTED 121bf0: 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) { 121bf2: 85 d2 test %edx,%edx <== NOT EXECUTED 121bf4: 75 ce jne 121bc4 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 121bf6: e8 e5 dd fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 121bfb: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121c00: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121c03: 5b pop %ebx <== NOT EXECUTED 121c04: 5e pop %esi <== NOT EXECUTED 121c05: c9 leave <== NOT EXECUTED 121c06: c3 ret <== NOT EXECUTED 00121c08 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 121c08: 55 push %ebp <== NOT EXECUTED 121c09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121c0b: 56 push %esi <== NOT EXECUTED 121c0c: 53 push %ebx <== NOT EXECUTED 121c0d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121c10: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 121c13: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 121c16: 85 db test %ebx,%ebx <== NOT EXECUTED 121c18: 74 48 je 121c62 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 121c1a: 85 f6 test %esi,%esi <== NOT EXECUTED 121c1c: 74 44 je 121c62 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 121c1e: 50 push %eax <== NOT EXECUTED 121c1f: 50 push %eax <== NOT EXECUTED 121c20: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 121c23: 50 push %eax <== NOT EXECUTED 121c24: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121c27: e8 d4 dd fe ff call 10fa00 <_Thread_Get> <== NOT EXECUTED 121c2c: 89 c2 mov %eax,%edx <== NOT EXECUTED switch (location) { 121c2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121c31: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 121c36: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 121c3a: 75 2b jne 121c67 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 121c3c: 8b 82 04 01 00 00 mov 0x104(%edx),%eax <== NOT EXECUTED 121c42: eb 15 jmp 121c59 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 121c44: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 121c47: 75 0e jne 121c57 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 121c49: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 121c4c: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 121c4e: e8 8d dd fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 121c53: 31 c0 xor %eax,%eax <== NOT EXECUTED 121c55: eb 10 jmp 121c67 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 121c57: 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) { 121c59: 85 c0 test %eax,%eax <== NOT EXECUTED 121c5b: 75 e7 jne 121c44 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 121c5d: e8 7e dd fe ff call 10f9e0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 121c62: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121c67: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121c6a: 5b pop %ebx <== NOT EXECUTED 121c6b: 5e pop %esi <== NOT EXECUTED 121c6c: c9 leave <== NOT EXECUTED 121c6d: 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 78 d6 11 00 mov 0x11d678,%eax <== NOT EXECUTED 1095a3: 40 inc %eax <== NOT EXECUTED 1095a4: a3 78 d6 11 00 mov %eax,0x11d678 <== 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 76 23 00 00 call 10b928 <_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 38 d7 11 00 pushl 0x11d738 <== NOT EXECUTED 1095be: e8 8d 20 00 00 call 10b650 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 1095c3: a1 38 d7 11 00 mov 0x11d738,%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 e4 ac 10 00 movl $0x10ace4,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 58 d7 11 00 push $0x11d758 <== NOT EXECUTED 1095f1: e8 06 26 00 00 call 10bbfc <_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 62 18 00 00 call 10ae60 <_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 b0 0c 12 00 00 cmpb $0x0,0x120cb0 <== 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 2c 0d 12 00 cmp 0x120d2c,%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 9c 0c 12 00 mov 0x120c9c,%eax <== NOT EXECUTED 10a17f: 40 inc %eax <== NOT EXECUTED 10a180: a3 9c 0c 12 00 mov %eax,0x120c9c <== 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 5c 0d 12 00 pushl 0x120d5c <== NOT EXECUTED 10a18f: e8 24 21 00 00 call 10c2b8 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a194: a1 5c 0d 12 00 mov 0x120d5c,%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 4c b9 10 00 movl $0x10b94c,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 2c 0d 12 00 sub 0x120d2c,%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 70 0d 12 00 push $0x120d70 <== NOT EXECUTED 10a1c8: e8 03 27 00 00 call 10c8d0 <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10a1cd: e8 f6 18 00 00 call 10bac8 <_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 1c b5 11 00 mov %eax,0x11b51c <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 10717f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107182: a3 20 b5 11 00 mov %eax,0x11b520 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107187: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10718a: a3 24 b5 11 00 mov %eax,0x11b524 <== 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 b4 d5 11 00 pushl 0x11d5b4 <== 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 30 d3 11 00 mov 0x11d330(%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 c0 13 00 00 call 109768 <== 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 b8 d5 11 00 mov %eax,0x11d5b8 <== 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 bc d5 11 00 mov %eax,0x11d5bc <== 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 b4 d5 11 00 pushl 0x11d5b4 <== 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 b3 23 00 00 call 109768 <== 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 e0 d3 11 00 mov 0x11d3e0,%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 3c d3 11 00 00 cmpl $0x0,0x11d33c(%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 3c d3 11 00 call *0x11d33c(%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 b4 d5 11 00 00 cmpl $0x0,0x11d5b4 <== NOT EXECUTED 107145: 75 28 jne 10716f <== NOT EXECUTED sc = rtems_semaphore_create ( 107147: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10714a: 68 b4 d5 11 00 push $0x11d5b4 <== 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 f9 25 00 00 call 109768 <== 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 44 d3 11 00 mov 0x11d344(%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 30 d3 11 00 mov 0x11d330(%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 2c d3 11 00 mov 0x11d32c(%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 b4 d5 11 00 pushl 0x11d5b4 <== 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 bc d5 11 00 mov 0x11d5bc,%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 20 b5 11 00 mov 0x11b520,%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 24 b5 11 00 mov 0x11b524,%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 1c b5 11 00 pushl 0x11b51c <== 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 b4 d5 11 00 pushl 0x11d5b4 <== 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 bc d5 11 00 mov 0x11d5bc,%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 bc d5 11 00 mov %ebx,0x11d5bc <== NOT EXECUTED if (rtems_termios_ttyTail == NULL) 1085de: 83 3d b8 d5 11 00 00 cmpl $0x0,0x11d5b8 <== NOT EXECUTED 1085e5: 75 06 jne 1085ed <== NOT EXECUTED rtems_termios_ttyTail = tty; 1085e7: 89 1d b8 d5 11 00 mov %ebx,0x11d5b8 <== 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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 movsbl 0x11b528,%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 28 b5 11 00 mov 0x11b528,%dl <== NOT EXECUTED 1087bf: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1087c2: a2 28 b5 11 00 mov %al,0x11b528 <== NOT EXECUTED 1087c7: 80 fa 7a cmp $0x7a,%dl <== NOT EXECUTED 1087ca: 75 07 jne 1087d3 <== NOT EXECUTED c = 'a'; 1087cc: c6 05 28 b5 11 00 61 movb $0x61,0x11b528 <== 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 18 0f 00 00 call 109768 <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 108850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108853: ff 35 b4 d5 11 00 pushl 0x11d5b4 <== 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 e6 43 00 00 call 10cc60 <== 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 71 20 00 00 call 109768 <== 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 34 d3 11 00 mov 0x11d334(%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 1c b5 11 00 mov 0x11b51c,%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 40 d3 11 00 mov 0x11d340(%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 38 d3 11 00 mov 0x11d338(%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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112abe: e8 09 25 00 00 call 114fcc <_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 db 3e 00 00 call 1169c0 <_Watchdog_Remove> <== NOT EXECUTED 112ae5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 112ae8: e8 9f 2c 00 00 call 11578c <_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 0010a00c : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 10a00c: 55 push %ebp <== NOT EXECUTED 10a00d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a00f: 57 push %edi <== NOT EXECUTED 10a010: 56 push %esi <== NOT EXECUTED 10a011: 53 push %ebx <== NOT EXECUTED 10a012: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a015: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a018: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10a01b: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10a020: 85 f6 test %esi,%esi <== NOT EXECUTED 10a022: 74 73 je 10a097 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10a024: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a029: 85 ff test %edi,%edi <== NOT EXECUTED 10a02b: 74 6a je 10a097 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a02d: a1 78 09 12 00 mov 0x120978,%eax <== NOT EXECUTED 10a032: 40 inc %eax <== NOT EXECUTED 10a033: a3 78 09 12 00 mov %eax,0x120978 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a038: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a03b: 68 60 0f 12 00 push $0x120f60 <== NOT EXECUTED 10a040: e8 f7 0d 00 00 call 10ae3c <_Objects_Allocate> <== NOT EXECUTED 10a045: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10a047: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a04a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a04c: 75 0c jne 10a05a <== NOT EXECUTED _Thread_Enable_dispatch(); 10a04e: e8 ed 19 00 00 call 10ba40 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a053: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a058: eb 3d jmp 10a097 <== NOT EXECUTED return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10a05a: 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. * 10a061: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a068: 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 10a06f: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED * the heap 10a076: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 10a07d: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 10a080: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a083: a1 7c 0f 12 00 mov 0x120f7c,%eax <== NOT EXECUTED 10a088: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a08b: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10a08e: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a090: e8 ab 19 00 00 call 10ba40 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a095: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a097: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a09a: 5b pop %ebx <== NOT EXECUTED 10a09b: 5e pop %esi <== NOT EXECUTED 10a09c: 5f pop %edi <== NOT EXECUTED 10a09d: c9 leave <== NOT EXECUTED 10a09e: 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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112b9b: e8 2c 24 00 00 call 114fcc <_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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112bb8: e8 03 20 00 00 call 114bc0 <_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 f8 3d 00 00 call 1169c0 <_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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112bd0: e8 87 22 00 00 call 114e5c <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 112bd5: e8 b2 2b 00 00 call 11578c <_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 0010a0a0 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10a0a0: 55 push %ebp <== NOT EXECUTED 10a0a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0a3: 57 push %edi <== NOT EXECUTED 10a0a4: 56 push %esi <== NOT EXECUTED 10a0a5: 53 push %ebx <== NOT EXECUTED 10a0a6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a0a9: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10a0ac: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a0b1: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10a0b5: 0f 84 8e 00 00 00 je 10a149 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 10a0bb: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a0c0: 85 ff test %edi,%edi <== NOT EXECUTED 10a0c2: 0f 84 81 00 00 00 je 10a149 <== 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 10a0c8: 52 push %edx <== NOT EXECUTED 10a0c9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a0cc: 50 push %eax <== NOT EXECUTED 10a0cd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a0d0: 68 60 0f 12 00 push $0x120f60 <== NOT EXECUTED 10a0d5: e8 a6 11 00 00 call 10b280 <_Objects_Get> <== NOT EXECUTED 10a0da: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10a0dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0df: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a0e4: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10a0e8: 75 5f jne 10a149 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10a0ea: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10a0ed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0f0: 56 push %esi <== NOT EXECUTED 10a0f1: e8 6a 28 00 00 call 10c960 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 10a0f6: 9c pushf <== NOT EXECUTED 10a0f7: fa cli <== NOT EXECUTED 10a0f8: 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 ) { 10a0f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0fc: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10a100: 74 0b je 10a10d <== NOT EXECUTED _ISR_Enable( level ); 10a102: 52 push %edx <== NOT EXECUTED 10a103: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 10a104: e8 37 19 00 00 call 10ba40 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a109: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a10b: eb 3c jmp 10a149 <== 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; 10a10d: 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. * 10a114: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a11b: 89 7b 2c mov %edi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a11e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a121: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 10a124: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a127: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10a12a: 52 push %edx <== NOT EXECUTED 10a12b: 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, 10a12c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a12f: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a132: 50 push %eax <== NOT EXECUTED 10a133: 50 push %eax <== NOT EXECUTED 10a134: 56 push %esi <== NOT EXECUTED 10a135: 68 58 0a 12 00 push $0x120a58 <== NOT EXECUTED 10a13a: e8 09 27 00 00 call 10c848 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10a13f: e8 fc 18 00 00 call 10ba40 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a144: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a146: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a149: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a14c: 5b pop %ebx <== NOT EXECUTED 10a14d: 5e pop %esi <== NOT EXECUTED 10a14e: 5f pop %edi <== NOT EXECUTED 10a14f: c9 leave <== NOT EXECUTED 10a150: 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 4c 40 13 00 00 cmpb $0x0,0x13404c <== 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 c8 40 13 00 cmp 0x1340c8,%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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112cfc: e8 cb 22 00 00 call 114fcc <_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 a3 3c 00 00 call 1169c0 <_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 c8 40 13 00 sub 0x1340c8,%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 0c 41 13 00 push $0x13410c <== NOT EXECUTED 112d4e: e8 55 3b 00 00 call 1168a8 <_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 34 2a 00 00 call 11578c <_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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112d8c: e8 3b 22 00 00 call 114fcc <_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 cf 29 00 00 call 11578c <_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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112dda: e8 35 23 00 00 call 115114 <_Objects_Name_to_id_u32> <== NOT EXECUTED 112ddf: 8b 04 85 8c 8d 12 00 mov 0x128d8c(,%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 c4 b8 12 00 movzbl 0x12b8c4,%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 38 40 13 00 mov 0x134038,%eax <== NOT EXECUTED 113059: 40 inc %eax <== NOT EXECUTED 11305a: a3 38 40 13 00 mov %eax,0x134038 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 11305f: 8a 1d ac fa 12 00 mov 0x12faac,%bl <== NOT EXECUTED initialized = true; 113065: c6 05 ac fa 12 00 01 movb $0x1,0x12faac <== NOT EXECUTED _Thread_Enable_dispatch(); 11306c: e8 1b 27 00 00 call 11578c <_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 cc 3f 13 00 d0 movl $0x133fd0,0x133fcc <== NOT EXECUTED 113085: 3f 13 00 <== NOT EXECUTED 113088: c7 05 d0 3f 13 00 00 movl $0x0,0x133fd0 <== NOT EXECUTED 11308f: 00 00 00 <== NOT EXECUTED 113092: c7 05 d4 3f 13 00 cc movl $0x133fcc,0x133fd4 <== NOT EXECUTED 113099: 3f 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 7c 3f 13 00 cmp 0x133f7c,%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 88 3f 13 00 mov 0x133f88,%eax <== NOT EXECUTED 1130dd: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 1130e0: a3 bc 49 13 00 mov %eax,0x1349bc <== NOT EXECUTED 1130e5: c7 05 ac 3f 13 00 b0 movl $0x133fb0,0x133fac <== NOT EXECUTED 1130ec: 3f 13 00 <== NOT EXECUTED 1130ef: c7 05 b0 3f 13 00 00 movl $0x0,0x133fb0 <== NOT EXECUTED 1130f6: 00 00 00 <== NOT EXECUTED 1130f9: c7 05 b4 3f 13 00 ac movl $0x133fac,0x133fb4 <== NOT EXECUTED 113100: 3f 13 00 <== NOT EXECUTED 113103: c7 05 c0 3f 13 00 c4 movl $0x133fc4,0x133fc0 <== NOT EXECUTED 11310a: 3f 13 00 <== NOT EXECUTED 11310d: c7 05 c4 3f 13 00 00 movl $0x0,0x133fc4 <== NOT EXECUTED 113114: 00 00 00 <== NOT EXECUTED 113117: c7 05 c8 3f 13 00 c0 movl $0x133fc0,0x133fc8 <== NOT EXECUTED 11311e: 3f 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 10 56 11 00 movl $0x115610,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 e0 3f 13 00 00 movl $0x0,0x133fe0 <== NOT EXECUTED 113140: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 113143: c7 05 f4 3f 13 00 10 movl $0x115610,0x133ff4 <== NOT EXECUTED 11314a: 56 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11314d: 89 0d f8 3f 13 00 mov %ecx,0x133ff8 <== NOT EXECUTED * the heap 113153: c7 05 fc 3f 13 00 00 movl $0x0,0x133ffc <== 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 b8 49 13 00 8b movl $0x11318b,0x1349b8 <== 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 ac fa 12 00 00 movb $0x0,0x12faac <== 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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112dfb: e8 cc 21 00 00 call 114fcc <_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 93 3b 00 00 call 1169c0 <_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 18 41 13 00 push $0x134118 <== NOT EXECUTED 112e35: e8 6e 3a 00 00 call 1168a8 <_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 b8 49 13 00 00 cmpl $0x0,0x1349b8 <== NOT EXECUTED 112e43: 75 0c jne 112e51 <== NOT EXECUTED _Thread_Enable_dispatch(); 112e45: e8 42 29 00 00 call 11578c <_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 63 3b 00 00 call 1169c0 <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 112e5d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 112e60: ff 15 b8 49 13 00 call *0x1349b8 <== 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 1c 29 00 00 call 11578c <_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 10 29 00 00 call 11578c <_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 bc 49 13 00 00 cmpl $0x0,0x1349bc <== 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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112ec8: e8 ff 20 00 00 call 114fcc <_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 d7 3a 00 00 call 1169c0 <_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 90 28 00 00 call 11578c <_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 b8 49 13 00 call *0x1349b8 <== NOT EXECUTED _Thread_Enable_dispatch(); 112f2c: e8 5b 28 00 00 call 11578c <_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 bc 49 13 00 00 cmpl $0x0,0x1349bc <== 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 4c 40 13 00 00 cmpb $0x0,0x13404c <== 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 c8 40 13 00 cmp 0x1340c8,%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 78 49 13 00 push $0x134978 <== NOT EXECUTED 112fb3: e8 14 20 00 00 call 114fcc <_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 ec 39 00 00 call 1169c0 <_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 c8 40 13 00 sub 0x1340c8,%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 b8 49 13 00 call *0x1349b8 <== NOT EXECUTED _Thread_Enable_dispatch(); 113003: e8 84 27 00 00 call 11578c <_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 00109415 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 109415: 55 push %ebp <== NOT EXECUTED 109416: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109418: 57 push %edi <== NOT EXECUTED 109419: 56 push %esi <== NOT EXECUTED 10941a: 53 push %ebx <== NOT EXECUTED 10941b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10941e: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 109421: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 109424: 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) 109426: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 10942b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10942e: 74 2a je 10945a <== NOT EXECUTED { if (rtems_panic_in_progress++) 109430: 8b 15 f8 97 12 00 mov 0x1297f8,%edx <== NOT EXECUTED 109436: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 109439: a3 f8 97 12 00 mov %eax,0x1297f8 <== NOT EXECUTED 10943e: 85 d2 test %edx,%edx <== NOT EXECUTED 109440: 74 0b je 10944d <== NOT EXECUTED 109442: a1 5c 99 12 00 mov 0x12995c,%eax <== NOT EXECUTED 109447: 40 inc %eax <== NOT EXECUTED 109448: a3 5c 99 12 00 mov %eax,0x12995c <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10944d: 83 3d f8 97 12 00 02 cmpl $0x2,0x1297f8 <== NOT EXECUTED 109454: 0f 8f 18 01 00 00 jg 109572 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10945a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10945d: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 109462: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109465: e8 82 ca 00 00 call 115eec <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 10946a: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED 10946d: 81 e6 ff ff ff 8f and $0x8fffffff,%esi <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 109473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109476: 31 ff xor %edi,%edi <== NOT EXECUTED 109478: f7 45 ec 00 00 00 40 testl $0x40000000,-0x14(%ebp) <== NOT EXECUTED 10947f: 74 07 je 109488 <== NOT EXECUTED local_errno = errno; 109481: e8 b6 c7 00 00 call 115c3c <__errno> <== NOT EXECUTED 109486: 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); 109488: 50 push %eax <== NOT EXECUTED 109489: 53 push %ebx <== NOT EXECUTED 10948a: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10948d: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 109492: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 109495: e8 72 20 01 00 call 11b50c <== NOT EXECUTED 10949a: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (status) 10949c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10949f: 85 f6 test %esi,%esi <== NOT EXECUTED 1094a1: 74 28 je 1094cb <== NOT EXECUTED const char * rtems_status_text( rtems_status_code status ) { return rtems_assoc_name_by_local(rtems_status_assoc, status); 1094a3: 50 push %eax <== NOT EXECUTED 1094a4: 50 push %eax <== NOT EXECUTED 1094a5: 56 push %esi <== NOT EXECUTED 1094a6: 68 2c 08 12 00 push $0x12082c <== NOT EXECUTED 1094ab: e8 80 85 00 00 call 111a30 <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 1094b0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1094b3: 50 push %eax <== NOT EXECUTED 1094b4: 68 1f 05 12 00 push $0x12051f <== NOT EXECUTED 1094b9: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 1094be: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1094c1: e8 8a cf 00 00 call 116450 <== NOT EXECUTED 1094c6: 01 c3 add %eax,%ebx <== NOT EXECUTED 1094c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (local_errno) 1094cb: 83 ff 00 cmp $0x0,%edi <== NOT EXECUTED 1094ce: 74 40 je 109510 <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 1094d0: 7e 25 jle 1094f7 <== NOT EXECUTED 1094d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094d5: 57 push %edi <== NOT EXECUTED 1094d6: e8 85 f5 00 00 call 118a60 <== NOT EXECUTED 1094db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094de: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 1094e1: 74 14 je 1094f7 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 1094e3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094e6: 57 push %edi <== NOT EXECUTED 1094e7: e8 74 f5 00 00 call 118a60 <== NOT EXECUTED 1094ec: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1094ef: 50 push %eax <== NOT EXECUTED 1094f0: 68 2d 05 12 00 push $0x12052d <== NOT EXECUTED 1094f5: eb 07 jmp 1094fe <== NOT EXECUTED else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 1094f7: 50 push %eax <== NOT EXECUTED 1094f8: 57 push %edi <== NOT EXECUTED 1094f9: 68 3a 05 12 00 push $0x12053a <== NOT EXECUTED 1094fe: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 109503: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 109506: e8 45 cf 00 00 call 116450 <== NOT EXECUTED 10950b: 01 c3 add %eax,%ebx <== NOT EXECUTED 10950d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 109510: 56 push %esi <== NOT EXECUTED 109511: 56 push %esi <== NOT EXECUTED 109512: 68 81 0d 12 00 push $0x120d81 <== NOT EXECUTED 109517: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 10951c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10951f: e8 2c cf 00 00 call 116450 <== NOT EXECUTED 109524: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) fflush(stderr); 109526: 59 pop %ecx <== NOT EXECUTED 109527: a1 e0 71 12 00 mov 0x1271e0,%eax <== NOT EXECUTED 10952c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10952f: e8 b8 c9 00 00 call 115eec <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 109534: 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"); 109537: 8d 04 1e lea (%esi,%ebx,1),%eax <== NOT EXECUTED (void) fflush(stderr); if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 10953a: f7 45 ec 00 00 00 30 testl $0x30000000,-0x14(%ebp) <== NOT EXECUTED 109541: 74 31 je 109574 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 109543: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109547: 74 16 je 10955f <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 109549: 52 push %edx <== NOT EXECUTED 10954a: 52 push %edx <== NOT EXECUTED 10954b: 68 4e 05 12 00 push $0x12054e <== NOT EXECUTED 109550: 6a 00 push $0x0 <== NOT EXECUTED 109552: e8 3d 00 00 00 call 109594 <== NOT EXECUTED _exit(local_errno); 109557: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10955a: e8 df 05 00 00 call 109b3e <_exit> <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); 10955f: 50 push %eax <== NOT EXECUTED 109560: 50 push %eax <== NOT EXECUTED 109561: 68 63 05 12 00 push $0x120563 <== NOT EXECUTED 109566: 6a 00 push $0x0 <== NOT EXECUTED 109568: e8 27 00 00 00 call 109594 <== NOT EXECUTED abort(); 10956d: e8 96 c6 00 00 call 115c08 <== NOT EXECUTED 109572: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 109574: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109577: 5b pop %ebx <== NOT EXECUTED 109578: 5e pop %esi <== NOT EXECUTED 109579: 5f pop %edi <== NOT EXECUTED 10957a: c9 leave <== NOT EXECUTED 10957b: c3 ret <== NOT EXECUTED 00109d31 : */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) { 109d31: 55 push %ebp <== NOT EXECUTED 109d32: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d34: 53 push %ebx <== NOT EXECUTED 109d35: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109d38: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109d3b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void *ptr; /* * check the arguments */ if ( !pointer ) 109d3e: 85 db test %ebx,%ebx <== NOT EXECUTED 109d40: 74 1e je 109d60 <== NOT EXECUTED return false; if ( !bytes ) 109d42: 85 c0 test %eax,%eax <== NOT EXECUTED 109d44: 74 1a je 109d60 <== NOT EXECUTED return false; /* * Allocate the memory */ ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); 109d46: 52 push %edx <== NOT EXECUTED 109d47: 52 push %edx <== NOT EXECUTED 109d48: 50 push %eax <== NOT EXECUTED 109d49: 68 c8 18 12 00 push $0x1218c8 <== NOT EXECUTED 109d4e: e8 c5 13 00 00 call 10b118 <_Protected_heap_Allocate> <== NOT EXECUTED if (!ptr) 109d53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d56: 85 c0 test %eax,%eax <== NOT EXECUTED 109d58: 74 06 je 109d60 <== NOT EXECUTED return false; *pointer = ptr; 109d5a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 109d5c: b0 01 mov $0x1,%al <== NOT EXECUTED 109d5e: eb 02 jmp 109d62 <== NOT EXECUTED return true; 109d60: 31 c0 xor %eax,%eax <== NOT EXECUTED } 109d62: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109d65: c9 leave <== NOT EXECUTED 109d66: c3 ret <== NOT EXECUTED 00109d1c : * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) { 109d1c: 55 push %ebp <== NOT EXECUTED 109d1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d1f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Protected_heap_Free( &_Workspace_Area, pointer ); 109d22: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d25: 68 c8 18 12 00 push $0x1218c8 <== NOT EXECUTED 109d2a: e8 1d 14 00 00 call 10b14c <_Protected_heap_Free> <== NOT EXECUTED } 109d2f: c9 leave <== NOT EXECUTED 109d30: c3 ret <== NOT EXECUTED 00109d67 : #include /* for memset */ bool rtems_workspace_get_information( Heap_Information_block *the_info ) { 109d67: 55 push %ebp <== NOT EXECUTED 109d68: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d6a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109d6d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_info ) 109d70: 31 c0 xor %eax,%eax <== NOT EXECUTED 109d72: 85 d2 test %edx,%edx <== NOT EXECUTED 109d74: 74 10 je 109d86 <== NOT EXECUTED return false; return _Protected_heap_Get_information( &_Workspace_Area, the_info ); 109d76: 51 push %ecx <== NOT EXECUTED 109d77: 51 push %ecx <== NOT EXECUTED 109d78: 52 push %edx <== NOT EXECUTED 109d79: 68 c8 18 12 00 push $0x1218c8 <== NOT EXECUTED 109d7e: e8 fd 13 00 00 call 10b180 <_Protected_heap_Get_information> <== NOT EXECUTED 109d83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d86: c9 leave <== NOT EXECUTED 109d87: c3 ret <== NOT EXECUTED 0011f66a : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 11f66a: 55 push %ebp <== NOT EXECUTED 11f66b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f66d: 57 push %edi <== NOT EXECUTED 11f66e: 56 push %esi <== NOT EXECUTED 11f66f: 53 push %ebx <== NOT EXECUTED 11f670: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11f673: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f675: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 11f678: 31 ff xor %edi,%edi <== NOT EXECUTED 11f67a: c7 45 f0 ff ff ff 7f movl $0x7fffffff,-0x10(%ebp) <== NOT EXECUTED 11f681: 31 db xor %ebx,%ebx <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 11f683: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 11f686: 48 dec %eax <== NOT EXECUTED 11f687: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 11f68a: 85 c0 test %eax,%eax <== NOT EXECUTED 11f68c: 79 16 jns 11f6a4 <== NOT EXECUTED 11f68e: 50 push %eax <== NOT EXECUTED 11f68f: 50 push %eax <== NOT EXECUTED 11f690: 56 push %esi <== NOT EXECUTED 11f691: ff 35 e0 5a 14 00 pushl 0x145ae0 <== NOT EXECUTED 11f697: e8 30 fb 00 00 call 12f1cc <__srget_r> <== NOT EXECUTED 11f69c: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 11f69f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f6a2: eb 0b jmp 11f6af <== NOT EXECUTED 11f6a4: 8b 06 mov (%esi),%eax <== NOT EXECUTED 11f6a6: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 11f6a9: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 11f6ac: 40 inc %eax <== NOT EXECUTED 11f6ad: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') 11f6af: 83 7d e8 3a cmpl $0x3a,-0x18(%ebp) <== NOT EXECUTED 11f6b3: 74 4c je 11f701 <== NOT EXECUTED break; if (sign == 0) { 11f6b5: 85 db test %ebx,%ebx <== NOT EXECUTED 11f6b7: 75 10 jne 11f6c9 <== NOT EXECUTED if (c == '-') { sign = -1; limit++; continue; 11f6b9: b3 01 mov $0x1,%bl <== NOT EXECUTED for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 11f6bb: 83 7d e8 2d cmpl $0x2d,-0x18(%ebp) <== NOT EXECUTED 11f6bf: 75 08 jne 11f6c9 <== NOT EXECUTED sign = -1; limit++; 11f6c1: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED 11f6c4: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 11f6c7: eb ba jmp 11f683 <== NOT EXECUTED continue; } sign = 1; } if (!isdigit(c)) 11f6c9: a1 c0 5a 14 00 mov 0x145ac0,%eax <== NOT EXECUTED 11f6ce: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 11f6d1: f6 04 08 04 testb $0x4,(%eax,%ecx,1) <== NOT EXECUTED 11f6d5: 74 3d je 11f714 <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 11f6d7: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f6da: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 11f6df: 31 d2 xor %edx,%edx <== NOT EXECUTED 11f6e1: f7 f1 div %ecx <== NOT EXECUTED 11f6e3: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 11f6e6: 39 c7 cmp %eax,%edi <== NOT EXECUTED 11f6e8: 77 2a ja 11f714 <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 11f6ea: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11f6ed: 83 ea 30 sub $0x30,%edx <== NOT EXECUTED if ((i > (limit / 10)) 11f6f0: 39 c7 cmp %eax,%edi <== NOT EXECUTED 11f6f2: 75 05 jne 11f6f9 <== NOT EXECUTED 11f6f4: 3b 55 e4 cmp -0x1c(%ebp),%edx <== NOT EXECUTED 11f6f7: 77 1b ja 11f714 <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 11f6f9: 6b c7 0a imul $0xa,%edi,%eax <== NOT EXECUTED 11f6fc: 8d 3c 02 lea (%edx,%eax,1),%edi <== NOT EXECUTED 11f6ff: eb 82 jmp 11f683 <== NOT EXECUTED } if (sign == 0) 11f701: 85 db test %ebx,%ebx <== NOT EXECUTED 11f703: 74 0f je 11f714 <== NOT EXECUTED return 0; *val = i * sign; 11f705: 0f af df imul %edi,%ebx <== NOT EXECUTED 11f708: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f70b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 11f70d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f712: eb 02 jmp 11f716 <== NOT EXECUTED return 1; 11f714: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f716: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f719: 5b pop %ebx <== NOT EXECUTED 11f71a: 5e pop %esi <== NOT EXECUTED 11f71b: 5f pop %edi <== NOT EXECUTED 11f71c: c9 leave <== NOT EXECUTED 11f71d: c3 ret <== NOT EXECUTED 0011f71e : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 11f71e: 55 push %ebp <== NOT EXECUTED 11f71f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f721: 57 push %edi <== NOT EXECUTED 11f722: 56 push %esi <== NOT EXECUTED 11f723: 53 push %ebx <== NOT EXECUTED 11f724: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f727: 89 c6 mov %eax,%esi <== NOT EXECUTED 11f729: 89 cb mov %ecx,%ebx <== NOT EXECUTED 11f72b: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED int c; *name = *bufp; 11f72e: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 11f730: 89 02 mov %eax,(%edx) <== NOT EXECUTED for (;;) { c = getc(fp); 11f732: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 11f735: 48 dec %eax <== NOT EXECUTED 11f736: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 11f739: 85 c0 test %eax,%eax <== NOT EXECUTED 11f73b: 79 15 jns 11f752 <== NOT EXECUTED 11f73d: 52 push %edx <== NOT EXECUTED 11f73e: 52 push %edx <== NOT EXECUTED 11f73f: 56 push %esi <== NOT EXECUTED 11f740: ff 35 e0 5a 14 00 pushl 0x145ae0 <== NOT EXECUTED 11f746: e8 81 fa 00 00 call 12f1cc <__srget_r> <== NOT EXECUTED 11f74b: 89 c2 mov %eax,%edx <== NOT EXECUTED 11f74d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f750: eb 08 jmp 11f75a <== NOT EXECUTED 11f752: 8b 06 mov (%esi),%eax <== NOT EXECUTED 11f754: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 11f757: 40 inc %eax <== NOT EXECUTED 11f758: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') { 11f75a: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 11f75d: 75 08 jne 11f767 <== NOT EXECUTED if (nlFlag) 11f75f: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11f763: 74 23 je 11f788 <== NOT EXECUTED 11f765: eb 31 jmp 11f798 <== NOT EXECUTED return 0; break; } if (c == '\n') { 11f767: 83 fa 0a cmp $0xa,%edx <== NOT EXECUTED 11f76a: 75 08 jne 11f774 <== NOT EXECUTED if (!nlFlag) 11f76c: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 11f770: 75 16 jne 11f788 <== NOT EXECUTED 11f772: eb 24 jmp 11f798 <== NOT EXECUTED return 0; break; } if (c == EOF) 11f774: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED 11f777: 74 1f je 11f798 <== NOT EXECUTED return 0; if (*nleft < 2) 11f779: 83 3f 01 cmpl $0x1,(%edi) <== NOT EXECUTED 11f77c: 76 1a jbe 11f798 <== NOT EXECUTED return 0; **bufp = c; 11f77e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 11f780: 88 10 mov %dl,(%eax) <== NOT EXECUTED ++(*bufp); 11f782: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 11f784: ff 0f decl (%edi) <== NOT EXECUTED 11f786: eb aa jmp 11f732 <== NOT EXECUTED } **bufp = '\0'; 11f788: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 11f78a: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED ++(*bufp); 11f78d: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 11f78f: ff 0f decl (%edi) <== NOT EXECUTED 11f791: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f796: eb 02 jmp 11f79a <== NOT EXECUTED return 1; 11f798: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f79a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f79d: 5b pop %ebx <== NOT EXECUTED 11f79e: 5e pop %esi <== NOT EXECUTED 11f79f: 5f pop %edi <== NOT EXECUTED 11f7a0: c9 leave <== NOT EXECUTED 11f7a1: c3 ret <== NOT EXECUTED 00108e17 : scandir( const char *dirname, struct dirent ***namelist, int (*select)(struct dirent *), int (*dcomp)(const struct dirent **, const struct dirent **)) { 108e17: 55 push %ebp <== NOT EXECUTED 108e18: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e1a: 57 push %edi <== NOT EXECUTED 108e1b: 56 push %esi <== NOT EXECUTED 108e1c: 53 push %ebx <== NOT EXECUTED 108e1d: 83 ec 78 sub $0x78,%esp <== NOT EXECUTED struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 108e20: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108e23: e8 f0 f8 ff ff call 108718 <== NOT EXECUTED 108e28: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED 108e2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e2e: 85 c0 test %eax,%eax <== NOT EXECUTED 108e30: 0f 84 99 01 00 00 je 108fcf <== NOT EXECUTED return(-1); if (fstat(dirp->dd_fd, &stb) < 0) 108e36: 51 push %ecx <== NOT EXECUTED 108e37: 51 push %ecx <== NOT EXECUTED 108e38: 8d 5d a8 lea -0x58(%ebp),%ebx <== NOT EXECUTED 108e3b: 53 push %ebx <== NOT EXECUTED 108e3c: ff 30 pushl (%eax) <== NOT EXECUTED 108e3e: e8 d1 5f 00 00 call 10ee14 <== NOT EXECUTED 108e43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e46: 85 c0 test %eax,%eax <== NOT EXECUTED 108e48: 0f 88 3d 01 00 00 js 108f8b <== NOT EXECUTED /* * estimate the array size by taking the size of the directory file * and dividing it by a multiple of the minimum size entry. */ arraysz = (stb.st_size / 24); 108e4e: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 108e51: b9 18 00 00 00 mov $0x18,%ecx <== NOT EXECUTED 108e56: 99 cltd <== NOT EXECUTED 108e57: f7 f9 idiv %ecx <== NOT EXECUTED 108e59: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 108e5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e5f: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 108e62: 50 push %eax <== NOT EXECUTED 108e63: e8 14 f1 ff ff call 107f7c <== NOT EXECUTED 108e68: 89 c6 mov %eax,%esi <== NOT EXECUTED if (names == NULL) 108e6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e6d: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp) <== NOT EXECUTED 108e74: 85 c0 test %eax,%eax <== NOT EXECUTED 108e76: 0f 85 c2 00 00 00 jne 108f3e <== NOT EXECUTED 108e7c: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 108e7f: e9 10 01 00 00 jmp 108f94 <== NOT EXECUTED goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { if (select != NULL && !(*select)(d)) 108e84: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 108e88: 74 12 je 108e9c <== NOT EXECUTED 108e8a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e8d: 53 push %ebx <== NOT EXECUTED 108e8e: ff 55 10 call *0x10(%ebp) <== NOT EXECUTED 108e91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e94: 85 c0 test %eax,%eax <== NOT EXECUTED 108e96: 0f 84 a2 00 00 00 je 108f3e <== NOT EXECUTED continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 108e9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e9f: 0f b7 43 0a movzwl 0xa(%ebx),%eax <== NOT EXECUTED 108ea3: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 108ea6: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 108ea9: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 108eac: 50 push %eax <== NOT EXECUTED 108ead: e8 ca f0 ff ff call 107f7c <== NOT EXECUTED 108eb2: 89 c7 mov %eax,%edi <== NOT EXECUTED if (p == NULL) 108eb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108eb7: 85 c0 test %eax,%eax <== NOT EXECUTED 108eb9: 0f 84 d5 00 00 00 je 108f94 <== NOT EXECUTED goto cleanup_and_bail; p->d_ino = d->d_ino; 108ebf: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 108ec1: 89 07 mov %eax,(%edi) <== NOT EXECUTED p->d_reclen = d->d_reclen; 108ec3: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 108ec6: 66 89 47 08 mov %ax,0x8(%edi) <== NOT EXECUTED p->d_namlen = d->d_namlen; 108eca: 0f b7 43 0a movzwl 0xa(%ebx),%eax <== NOT EXECUTED 108ece: 66 89 47 0a mov %ax,0xa(%edi) <== NOT EXECUTED strncpy(p->d_name, d->d_name, p->d_namlen + 1); 108ed2: 52 push %edx <== NOT EXECUTED 108ed3: 40 inc %eax <== NOT EXECUTED 108ed4: 50 push %eax <== NOT EXECUTED 108ed5: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 108ed8: 50 push %eax <== NOT EXECUTED 108ed9: 8d 47 0c lea 0xc(%edi),%eax <== NOT EXECUTED 108edc: 50 push %eax <== NOT EXECUTED 108edd: e8 32 a9 00 00 call 113814 <== NOT EXECUTED /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { 108ee2: ff 45 98 incl -0x68(%ebp) <== NOT EXECUTED 108ee5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ee8: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED 108eeb: 39 45 98 cmp %eax,-0x68(%ebp) <== NOT EXECUTED 108eee: 72 40 jb 108f30 <== NOT EXECUTED if (fstat(dirp->dd_fd, &stb) < 0) 108ef0: 51 push %ecx <== NOT EXECUTED 108ef1: 51 push %ecx <== NOT EXECUTED 108ef2: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 108ef5: 52 push %edx <== NOT EXECUTED 108ef6: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 108ef9: ff 30 pushl (%eax) <== NOT EXECUTED 108efb: e8 14 5f 00 00 call 10ee14 <== NOT EXECUTED 108f00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f03: 85 c0 test %eax,%eax <== NOT EXECUTED 108f05: 0f 88 89 00 00 00 js 108f94 <== NOT EXECUTED goto cleanup_and_bail; /* just might have grown */ arraysz = stb.st_size / 12; 108f0b: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 108f0e: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 108f13: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108f15: 99 cltd <== NOT EXECUTED 108f16: f7 fb idiv %ebx <== NOT EXECUTED 108f18: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, 108f1b: 52 push %edx <== NOT EXECUTED 108f1c: 52 push %edx <== NOT EXECUTED 108f1d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 108f20: 50 push %eax <== NOT EXECUTED 108f21: 56 push %esi <== NOT EXECUTED 108f22: e8 d9 60 00 00 call 10f000 <== NOT EXECUTED 108f27: 89 c6 mov %eax,%esi <== NOT EXECUTED arraysz * sizeof(struct dirent *)); if (names == NULL) 108f29: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f2c: 85 c0 test %eax,%eax <== NOT EXECUTED 108f2e: 74 64 je 108f94 <== NOT EXECUTED goto cleanup_and_bail; } names[nitems-1] = p; 108f30: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108f35: 2b 45 98 sub -0x68(%ebp),%eax <== NOT EXECUTED 108f38: 6b c0 fc imul $0xfffffffc,%eax,%eax <== NOT EXECUTED 108f3b: 89 3c 30 mov %edi,(%eax,%esi,1) <== NOT EXECUTED arraysz = (stb.st_size / 24); names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { 108f3e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f41: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 108f44: e8 1f fd ff ff call 108c68 <== NOT EXECUTED 108f49: 89 c3 mov %eax,%ebx <== NOT EXECUTED 108f4b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f4e: 85 c0 test %eax,%eax <== NOT EXECUTED 108f50: 0f 85 2e ff ff ff jne 108e84 <== NOT EXECUTED if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; } closedir(dirp); 108f56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f59: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 108f5c: e8 13 e7 ff ff call 107674 <== NOT EXECUTED if (nitems && dcomp != NULL){ 108f61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f64: 83 7d 98 00 cmpl $0x0,-0x68(%ebp) <== NOT EXECUTED 108f68: 74 17 je 108f81 <== NOT EXECUTED 108f6a: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 108f6e: 74 11 je 108f81 <== NOT EXECUTED qsort(names, nitems, sizeof(struct dirent *), 108f70: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 108f73: 6a 04 push $0x4 <== NOT EXECUTED 108f75: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 108f78: 56 push %esi <== NOT EXECUTED 108f79: e8 0a 9d 00 00 call 112c88 <== NOT EXECUTED 108f7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (int (*)(const void *, const void *)) dcomp); } *namelist = names; 108f81: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108f84: 89 30 mov %esi,(%eax) <== NOT EXECUTED return(nitems); 108f86: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 108f89: eb 47 jmp 108fd2 <== NOT EXECUTED 108f8b: 31 f6 xor %esi,%esi <== NOT EXECUTED 108f8d: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp) <== NOT EXECUTED cleanup_and_bail: if ( dirp ) closedir( dirp ); 108f94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f97: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 108f9a: e8 d5 e6 ff ff call 107674 <== NOT EXECUTED if ( names ) { 108f9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fa2: 31 db xor %ebx,%ebx <== NOT EXECUTED 108fa4: 85 f6 test %esi,%esi <== NOT EXECUTED 108fa6: 74 27 je 108fcf <== NOT EXECUTED 108fa8: eb 0f jmp 108fb9 <== NOT EXECUTED for (i=0; i < nitems; i++ ) free( names[i] ); 108faa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fad: ff 34 9e pushl (%esi,%ebx,4) <== NOT EXECUTED 108fb0: e8 93 ea ff ff call 107a48 <== NOT EXECUTED if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 108fb5: 43 inc %ebx <== NOT EXECUTED 108fb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fb9: 3b 5d 98 cmp -0x68(%ebp),%ebx <== NOT EXECUTED 108fbc: 72 ec jb 108faa <== NOT EXECUTED free( names[i] ); free( names ); 108fbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fc1: 56 push %esi <== NOT EXECUTED 108fc2: e8 81 ea ff ff call 107a48 <== NOT EXECUTED 108fc7: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108fca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fcd: eb 03 jmp 108fd2 <== NOT EXECUTED 108fcf: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } return(-1); } 108fd2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108fd5: 5b pop %ebx <== NOT EXECUTED 108fd6: 5e pop %esi <== NOT EXECUTED 108fd7: 5f pop %edi <== NOT EXECUTED 108fd8: c9 leave <== NOT EXECUTED 108fd9: c3 ret <== NOT EXECUTED 0011f7a2 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 11f7a2: 55 push %ebp <== NOT EXECUTED 11f7a3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f7a5: 57 push %edi <== NOT EXECUTED 11f7a6: 56 push %esi <== NOT EXECUTED 11f7a7: 53 push %ebx <== NOT EXECUTED 11f7a8: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 11f7ab: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f7ad: 89 d6 mov %edx,%esi <== NOT EXECUTED 11f7af: 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) 11f7b2: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 11f7b5: 6a 00 push $0x0 <== NOT EXECUTED 11f7b7: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f7ba: 50 push %eax <== NOT EXECUTED 11f7bb: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f7bd: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f7bf: e8 5a ff ff ff call 11f71e <== NOT EXECUTED 11f7c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f7c7: 85 c0 test %eax,%eax <== NOT EXECUTED 11f7c9: 0f 84 bf 00 00 00 je 11f88e <== NOT EXECUTED 11f7cf: 50 push %eax <== NOT EXECUTED 11f7d0: 50 push %eax <== NOT EXECUTED 11f7d1: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 11f7d4: 6a 00 push $0x0 <== NOT EXECUTED 11f7d6: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f7d9: 50 push %eax <== NOT EXECUTED 11f7da: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f7dc: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f7de: e8 3b ff ff ff call 11f71e <== NOT EXECUTED 11f7e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f7e6: 85 c0 test %eax,%eax <== NOT EXECUTED 11f7e8: 0f 84 a0 00 00 00 je 11f88e <== NOT EXECUTED 11f7ee: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 11f7f1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f7f3: e8 72 fe ff ff call 11f66a <== NOT EXECUTED 11f7f8: 85 c0 test %eax,%eax <== NOT EXECUTED 11f7fa: 0f 84 8e 00 00 00 je 11f88e <== NOT EXECUTED 11f800: 51 push %ecx <== NOT EXECUTED 11f801: 51 push %ecx <== NOT EXECUTED 11f802: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 11f805: 6a 01 push $0x1 <== NOT EXECUTED 11f807: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f80a: 50 push %eax <== NOT EXECUTED 11f80b: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f80d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f80f: e8 0a ff ff ff call 11f71e <== NOT EXECUTED 11f814: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f817: 85 c0 test %eax,%eax <== NOT EXECUTED 11f819: 74 73 je 11f88e <== 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; 11f81b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f81e: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f822: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 11f825: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 11f827: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 11f82c: eb 0b jmp 11f839 <== NOT EXECUTED if(*cp == ',') memcount++; 11f82e: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 11f830: 0f 94 c0 sete %al <== NOT EXECUTED 11f833: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 11f836: 01 c2 add %eax,%edx <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f838: 41 inc %ecx <== NOT EXECUTED 11f839: 8a 01 mov (%ecx),%al <== NOT EXECUTED 11f83b: 84 c0 test %al,%al <== NOT EXECUTED 11f83d: 75 ef jne 11f82e <== NOT EXECUTED } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 11f83f: 8d 04 95 13 00 00 00 lea 0x13(,%edx,4),%eax <== NOT EXECUTED 11f846: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 11f849: 72 43 jb 11f88e <== NOT EXECUTED return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 11f84b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11f84e: 83 c0 0f add $0xf,%eax <== NOT EXECUTED 11f851: 83 e0 f0 and $0xfffffff0,%eax <== NOT EXECUTED 11f854: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 11f857: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 11f859: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f85c: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 11f85f: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 11f864: eb 10 jmp 11f876 <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { if(*cp == ',') { 11f866: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 11f868: 75 0b jne 11f875 <== NOT EXECUTED *cp = '\0'; 11f86a: c6 42 ff 00 movb $0x0,-0x1(%edx) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 11f86e: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 11f871: 89 14 88 mov %edx,(%eax,%ecx,4) <== NOT EXECUTED 11f874: 41 inc %ecx <== NOT EXECUTED 11f875: 42 inc %edx <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 11f876: 8a 42 ff mov -0x1(%edx),%al <== NOT EXECUTED 11f879: 84 c0 test %al,%al <== NOT EXECUTED 11f87b: 75 e9 jne 11f866 <== NOT EXECUTED if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 11f87d: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 11f880: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) <== NOT EXECUTED 11f887: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f88c: eb 02 jmp 11f890 <== NOT EXECUTED return 1; 11f88e: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f890: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f893: 5b pop %ebx <== NOT EXECUTED 11f894: 5e pop %esi <== NOT EXECUTED 11f895: 5f pop %edi <== NOT EXECUTED 11f896: c9 leave <== NOT EXECUTED 11f897: c3 ret <== NOT EXECUTED 0011f8d0 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 11f8d0: 55 push %ebp <== NOT EXECUTED 11f8d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11f8d3: 57 push %edi <== NOT EXECUTED 11f8d4: 56 push %esi <== NOT EXECUTED 11f8d5: 53 push %ebx <== NOT EXECUTED 11f8d6: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 11f8d9: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11f8db: 89 d6 mov %edx,%esi <== NOT EXECUTED 11f8dd: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 11f8e0: 8d 7d e0 lea -0x20(%ebp),%edi <== 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 2c fe ff ff call 11f71e <== NOT EXECUTED 11f8f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f8f5: 85 c0 test %eax,%eax <== NOT EXECUTED 11f8f7: 0f 84 c4 00 00 00 je 11f9c1 <== NOT EXECUTED 11f8fd: 50 push %eax <== NOT EXECUTED 11f8fe: 50 push %eax <== NOT EXECUTED 11f8ff: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 11f902: 6a 00 push $0x0 <== NOT EXECUTED 11f904: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f907: 50 push %eax <== NOT EXECUTED 11f908: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f90a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f90c: e8 0d fe ff ff call 11f71e <== NOT EXECUTED 11f911: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f914: 85 c0 test %eax,%eax <== NOT EXECUTED 11f916: 0f 84 a5 00 00 00 je 11f9c1 <== NOT EXECUTED 11f91c: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 11f91f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f921: e8 44 fd ff ff call 11f66a <== NOT EXECUTED 11f926: 85 c0 test %eax,%eax <== NOT EXECUTED 11f928: 0f 84 93 00 00 00 je 11f9c1 <== NOT EXECUTED 11f92e: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 11f931: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f933: e8 32 fd ff ff call 11f66a <== NOT EXECUTED 11f938: 85 c0 test %eax,%eax <== NOT EXECUTED 11f93a: 0f 84 81 00 00 00 je 11f9c1 <== NOT EXECUTED 11f940: 50 push %eax <== NOT EXECUTED 11f941: 50 push %eax <== NOT EXECUTED 11f942: 8d 56 0c lea 0xc(%esi),%edx <== NOT EXECUTED 11f945: 6a 00 push $0x0 <== NOT EXECUTED 11f947: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f94a: 50 push %eax <== NOT EXECUTED 11f94b: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f94d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f94f: e8 ca fd ff ff call 11f71e <== NOT EXECUTED 11f954: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f957: 85 c0 test %eax,%eax <== NOT EXECUTED 11f959: 74 66 je 11f9c1 <== NOT EXECUTED 11f95b: 50 push %eax <== NOT EXECUTED 11f95c: 50 push %eax <== NOT EXECUTED 11f95d: 8d 56 10 lea 0x10(%esi),%edx <== NOT EXECUTED 11f960: 6a 00 push $0x0 <== NOT EXECUTED 11f962: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f965: 50 push %eax <== NOT EXECUTED 11f966: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f968: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f96a: e8 af fd ff ff call 11f71e <== NOT EXECUTED 11f96f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f972: 85 c0 test %eax,%eax <== NOT EXECUTED 11f974: 74 4b je 11f9c1 <== NOT EXECUTED 11f976: 50 push %eax <== NOT EXECUTED 11f977: 50 push %eax <== NOT EXECUTED 11f978: 8d 56 14 lea 0x14(%esi),%edx <== NOT EXECUTED 11f97b: 6a 00 push $0x0 <== NOT EXECUTED 11f97d: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f980: 50 push %eax <== NOT EXECUTED 11f981: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f983: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f985: e8 94 fd ff ff call 11f71e <== NOT EXECUTED 11f98a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f98d: 85 c0 test %eax,%eax <== NOT EXECUTED 11f98f: 74 30 je 11f9c1 <== NOT EXECUTED 11f991: 50 push %eax <== NOT EXECUTED 11f992: 50 push %eax <== NOT EXECUTED 11f993: 8d 56 18 lea 0x18(%esi),%edx <== NOT EXECUTED 11f996: 6a 01 push $0x1 <== NOT EXECUTED 11f998: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 11f99b: 50 push %eax <== NOT EXECUTED 11f99c: 89 f9 mov %edi,%ecx <== NOT EXECUTED 11f99e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11f9a0: e8 79 fd ff ff call 11f71e <== NOT EXECUTED 11f9a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f9a8: 85 c0 test %eax,%eax <== NOT EXECUTED 11f9aa: 74 15 je 11f9c1 <== 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; 11f9ac: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11f9af: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED pwd->pw_gid = pwgid; 11f9b3: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11f9b6: 66 89 46 0a mov %ax,0xa(%esi) <== NOT EXECUTED 11f9ba: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11f9bf: eb 02 jmp 11f9c3 <== NOT EXECUTED return 1; 11f9c1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11f9c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11f9c6: 5b pop %ebx <== NOT EXECUTED 11f9c7: 5e pop %esi <== NOT EXECUTED 11f9c8: 5f pop %edi <== NOT EXECUTED 11f9c9: c9 leave <== NOT EXECUTED 11f9ca: c3 ret <== NOT EXECUTED 0010a104 : #include int sched_get_priority_max( int policy ) { 10a104: 55 push %ebp <== NOT EXECUTED 10a105: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a107: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10a10a: b8 fe 00 00 00 mov $0xfe,%eax <== NOT EXECUTED 10a10f: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10a113: 76 0e jbe 10a123 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a115: e8 76 66 00 00 call 110790 <__errno> <== NOT EXECUTED 10a11a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a120: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10a123: c9 leave <== NOT EXECUTED 10a124: c3 ret <== NOT EXECUTED 0010a128 : #include int sched_get_priority_min( int policy ) { 10a128: 55 push %ebp <== NOT EXECUTED 10a129: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10a12e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a133: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10a137: 76 0e jbe 10a147 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a139: e8 52 66 00 00 call 110790 <__errno> <== NOT EXECUTED 10a13e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a144: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a147: c9 leave <== NOT EXECUTED 10a148: c3 ret <== NOT EXECUTED 001092ac : int sched_getparam( pid_t pid, const struct sched_param *param ) { 1092ac: 55 push %ebp <== NOT EXECUTED 1092ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1092b2: e8 1d 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1092b7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1092bd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1092c0: c9 leave <== NOT EXECUTED 1092c1: c3 ret <== NOT EXECUTED 001092c4 : #include int sched_getscheduler( pid_t pid ) { 1092c4: 55 push %ebp <== NOT EXECUTED 1092c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1092ca: e8 05 6b 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1092cf: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1092d5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1092d8: c9 leave <== NOT EXECUTED 1092d9: c3 ret <== NOT EXECUTED 0010a14c : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a14c: 55 push %ebp <== NOT EXECUTED 10a14d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a14f: 56 push %esi <== NOT EXECUTED 10a150: 53 push %ebx <== NOT EXECUTED 10a151: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a154: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a157: 85 db test %ebx,%ebx <== NOT EXECUTED 10a159: 74 16 je 10a171 <== NOT EXECUTED 10a15b: e8 70 d1 ff ff call 1072d0 <== NOT EXECUTED 10a160: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10a162: 74 0d je 10a171 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); 10a164: e8 27 66 00 00 call 110790 <__errno> <== NOT EXECUTED 10a169: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 10a16f: eb 0f jmp 10a180 <== NOT EXECUTED if ( !interval ) 10a171: 85 f6 test %esi,%esi <== NOT EXECUTED 10a173: 75 10 jne 10a185 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10a175: e8 16 66 00 00 call 110790 <__errno> <== NOT EXECUTED 10a17a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a180: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10a183: eb 13 jmp 10a198 <== NOT EXECUTED _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a185: 50 push %eax <== NOT EXECUTED 10a186: 50 push %eax <== NOT EXECUTED 10a187: 56 push %esi <== NOT EXECUTED 10a188: ff 35 9c 0f 12 00 pushl 0x120f9c <== NOT EXECUTED 10a18e: e8 45 32 00 00 call 10d3d8 <_Timespec_From_ticks> <== NOT EXECUTED 10a193: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a195: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a198: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a19b: 5b pop %ebx <== NOT EXECUTED 10a19c: 5e pop %esi <== NOT EXECUTED 10a19d: c9 leave <== NOT EXECUTED 10a19e: c3 ret <== NOT EXECUTED 001092dc : int sched_setparam( pid_t pid, const struct sched_param *param ) { 1092dc: 55 push %ebp <== NOT EXECUTED 1092dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1092e2: e8 ed 6a 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1092e7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 1092ed: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1092f0: c9 leave <== NOT EXECUTED 1092f1: c3 ret <== NOT EXECUTED 001092f4 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 1092f4: 55 push %ebp <== NOT EXECUTED 1092f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 1092fa: e8 d5 6a 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 1092ff: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109305: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109308: c9 leave <== NOT EXECUTED 109309: c3 ret <== NOT EXECUTED 0010a1a0 : #include #include #include int sched_yield( void ) { 10a1a0: 55 push %ebp <== NOT EXECUTED 10a1a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1a3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a1a6: a1 d0 0f 12 00 mov 0x120fd0,%eax <== NOT EXECUTED 10a1ab: 40 inc %eax <== NOT EXECUTED 10a1ac: a3 d0 0f 12 00 mov %eax,0x120fd0 <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 10a1b1: e8 92 31 00 00 call 10d348 <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a1b6: e8 99 26 00 00 call 10c854 <_Thread_Enable_dispatch> <== NOT EXECUTED return 0; } 10a1bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a1bd: c9 leave <== NOT EXECUTED 10a1be: c3 ret <== NOT EXECUTED 00108fdc : void seekdir( DIR *dirp, long loc ) { 108fdc: 55 push %ebp <== NOT EXECUTED 108fdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108fdf: 53 push %ebx <== NOT EXECUTED 108fe0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 108fe3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED off_t status; if ( !dirp ) 108fe6: 85 db test %ebx,%ebx <== NOT EXECUTED 108fe8: 74 1a je 109004 <== NOT EXECUTED return; status = lseek( dirp->dd_fd, loc, SEEK_SET ); 108fea: 50 push %eax <== NOT EXECUTED 108feb: 6a 00 push $0x0 <== NOT EXECUTED 108fed: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108ff0: ff 33 pushl (%ebx) <== NOT EXECUTED 108ff2: e8 d5 ed ff ff call 107dcc <== NOT EXECUTED /* * This is not a nice way to error out, but we have no choice here. */ if ( status == -1 ) 108ff7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ffa: 40 inc %eax <== NOT EXECUTED 108ffb: 74 07 je 109004 <== NOT EXECUTED return; dirp->dd_loc = 0; 108ffd: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED } 109004: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109007: c9 leave <== NOT EXECUTED 109008: c3 ret <== NOT EXECUTED 0010b54c : */ int sem_close( sem_t *sem ) { 10b54c: 55 push %ebp <== NOT EXECUTED 10b54d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b54f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 10b552: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b555: 50 push %eax <== NOT EXECUTED 10b556: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b559: ff 30 pushl (%eax) <== NOT EXECUTED 10b55b: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b560: e8 97 1f 00 00 call 10d4fc <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10b565: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b568: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b56c: 75 18 jne 10b586 <== NOT EXECUTED case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 10b56e: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); 10b571: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b574: 50 push %eax <== NOT EXECUTED 10b575: e8 ee 55 00 00 call 110b68 <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b57a: e8 3d 27 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b57f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b581: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b584: eb 0e jmp 10b594 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b586: e8 69 70 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b58b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b591: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10b594: c9 leave <== NOT EXECUTED 10b595: c3 ret <== NOT EXECUTED 0010b598 : */ int sem_destroy( sem_t *sem ) { 10b598: 55 push %ebp <== NOT EXECUTED 10b599: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b59b: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b59e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b5a1: 50 push %eax <== NOT EXECUTED 10b5a2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b5a5: ff 30 pushl (%eax) <== NOT EXECUTED 10b5a7: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b5ac: e8 4b 1f 00 00 call 10d4fc <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10b5b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5b4: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b5b8: 75 22 jne 10b5dc <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 10b5ba: 80 78 14 00 cmpb $0x0,0x14(%eax) <== NOT EXECUTED 10b5be: 74 07 je 10b5c7 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b5c0: e8 f7 26 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b5c5: eb 15 jmp 10b5dc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10b5c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5ca: 50 push %eax <== NOT EXECUTED 10b5cb: e8 98 55 00 00 call 110b68 <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b5d0: e8 e7 26 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b5d5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b5d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5da: eb 0e jmp 10b5ea <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b5dc: e8 13 70 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b5e1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b5e7: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10b5ea: c9 leave <== NOT EXECUTED 10b5eb: c3 ret <== NOT EXECUTED 0010b5ec : int sem_getvalue( sem_t *sem, int *sval ) { 10b5ec: 55 push %ebp <== NOT EXECUTED 10b5ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5ef: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b5f2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b5f5: 50 push %eax <== NOT EXECUTED 10b5f6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b5f9: ff 30 pushl (%eax) <== NOT EXECUTED 10b5fb: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b600: e8 f7 1e 00 00 call 10d4fc <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10b605: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b608: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b60c: 75 11 jne 10b61f <== NOT EXECUTED case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 10b60e: 8b 50 64 mov 0x64(%eax),%edx <== NOT EXECUTED 10b611: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b614: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b616: e8 a1 26 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b61b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b61d: eb 0e jmp 10b62d <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b61f: e8 d0 6f 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b624: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b62a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10b62d: c9 leave <== NOT EXECUTED 10b62e: c3 ret <== NOT EXECUTED 0010b630 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10b630: 55 push %ebp <== NOT EXECUTED 10b631: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b633: 53 push %ebx <== NOT EXECUTED 10b634: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b637: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10b63a: 85 db test %ebx,%ebx <== NOT EXECUTED 10b63c: 75 10 jne 10b64e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10b63e: e8 b1 6f 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b643: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b649: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10b64c: eb 23 jmp 10b671 <== NOT EXECUTED status = _POSIX_Semaphore_Create_support( 10b64e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b651: 50 push %eax <== NOT EXECUTED 10b652: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10b655: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b658: 6a 00 push $0x0 <== NOT EXECUTED 10b65a: e8 11 54 00 00 call 110a70 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10b65f: 89 c2 mov %eax,%edx <== NOT EXECUTED pshared, value, &the_semaphore ); if ( status != -1 ) 10b661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b664: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10b667: 74 08 je 10b671 <== NOT EXECUTED *sem = the_semaphore->Object.id; 10b669: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10b66c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b66f: 89 03 mov %eax,(%ebx) <== NOT EXECUTED return status; } 10b671: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b673: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b676: c9 leave <== NOT EXECUTED 10b677: c3 ret <== NOT EXECUTED 0010b678 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10b678: 55 push %ebp <== NOT EXECUTED 10b679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b67b: 57 push %edi <== NOT EXECUTED 10b67c: 56 push %esi <== NOT EXECUTED 10b67d: 53 push %ebx <== NOT EXECUTED 10b67e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b681: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b684: a1 f0 33 12 00 mov 0x1233f0,%eax <== NOT EXECUTED 10b689: 40 inc %eax <== NOT EXECUTED 10b68a: a3 f0 33 12 00 mov %eax,0x1233f0 <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10b68f: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b691: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10b696: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10b699: 75 04 jne 10b69f <== NOT EXECUTED 10b69b: 31 ff xor %edi,%edi <== NOT EXECUTED 10b69d: eb 03 jmp 10b6a2 <== NOT EXECUTED va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10b69f: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10b6a2: 52 push %edx <== NOT EXECUTED 10b6a3: 52 push %edx <== NOT EXECUTED 10b6a4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b6a7: 50 push %eax <== NOT EXECUTED 10b6a8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b6ab: e8 00 55 00 00 call 110bb0 <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10b6b0: 89 c3 mov %eax,%ebx <== NOT EXECUTED * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10b6b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6b5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b6b7: 74 19 je 10b6d2 <== NOT EXECUTED /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10b6b9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b6bc: 75 06 jne 10b6c4 <== NOT EXECUTED 10b6be: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 10b6c2: 75 5e jne 10b722 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b6c4: e8 f3 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10b6c9: e8 26 6f 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b6ce: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10b6d0: eb 1e jmp 10b6f0 <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10b6d2: 81 e6 00 0a 00 00 and $0xa00,%esi <== NOT EXECUTED 10b6d8: 81 fe 00 0a 00 00 cmp $0xa00,%esi <== NOT EXECUTED 10b6de: 75 15 jne 10b6f5 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b6e0: e8 d7 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10b6e5: e8 0a 6f 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b6ea: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10b6f0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b6f3: eb 52 jmp 10b747 <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 10b6f5: 50 push %eax <== NOT EXECUTED 10b6f6: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b6f9: 50 push %eax <== NOT EXECUTED 10b6fa: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b6fd: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b702: e8 f5 1d 00 00 call 10d4fc <_Objects_Get> <== NOT EXECUTED } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10b707: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_semaphore->open_count += 1; 10b70a: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b70d: e8 aa 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b712: e8 a5 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED id = &the_semaphore->Object.id; return (sem_t *)id; 10b717: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b71a: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10b71d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b720: eb 25 jmp 10b747 <== NOT EXECUTED /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10b722: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b725: 50 push %eax <== NOT EXECUTED 10b726: 57 push %edi <== NOT EXECUTED 10b727: 6a 00 push $0x0 <== NOT EXECUTED 10b729: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b72c: e8 3f 53 00 00 call 110a70 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10b731: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10b733: e8 84 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED if ( status == -1 ) 10b738: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b73b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b73e: 43 inc %ebx <== NOT EXECUTED 10b73f: 74 06 je 10b747 <== NOT EXECUTED return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 10b741: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b744: 83 c0 08 add $0x8,%eax <== NOT EXECUTED } 10b747: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b74a: 5b pop %ebx <== NOT EXECUTED 10b74b: 5e pop %esi <== NOT EXECUTED 10b74c: 5f pop %edi <== NOT EXECUTED 10b74d: c9 leave <== NOT EXECUTED 10b74e: c3 ret <== NOT EXECUTED 0010b750 : */ int sem_post( sem_t *sem ) { 10b750: 55 push %ebp <== NOT EXECUTED 10b751: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b753: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b756: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b759: 50 push %eax <== NOT EXECUTED 10b75a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b75d: ff 30 pushl (%eax) <== NOT EXECUTED 10b75f: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b764: e8 93 1d 00 00 call 10d4fc <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10b769: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b76c: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b770: 75 1b jne 10b78d <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 10b772: 52 push %edx <== NOT EXECUTED 10b773: 6a 00 push $0x0 <== NOT EXECUTED 10b775: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10b778: 83 c0 1c add $0x1c,%eax <== NOT EXECUTED 10b77b: 50 push %eax <== NOT EXECUTED 10b77c: e8 b3 15 00 00 call 10cd34 <_CORE_semaphore_Surrender> <== NOT EXECUTED NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10b781: e8 36 25 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b786: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b788: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b78b: eb 0e jmp 10b79b <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b78d: e8 62 6e 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b792: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b798: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10b79b: c9 leave <== NOT EXECUTED 10b79c: c3 ret <== NOT EXECUTED 0010b7a0 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10b7a0: 55 push %ebp <== NOT EXECUTED 10b7a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7a3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b7a6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b7a9: 50 push %eax <== NOT EXECUTED 10b7aa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b7ad: e8 7a 4a 00 00 call 11022c <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10b7b2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b7b5: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b7b8: 0f 97 c0 seta %al <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10b7bb: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10b7be: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10b7c1: 50 push %eax <== NOT EXECUTED 10b7c2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b7c5: e8 46 54 00 00 call 110c10 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED break; } } return lock_status; } 10b7ca: c9 leave <== NOT EXECUTED 10b7cb: c3 ret <== NOT EXECUTED 0010b7cc : */ int sem_trywait( sem_t *sem ) { 10b7cc: 55 push %ebp <== NOT EXECUTED 10b7cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support(sem, FALSE, THREAD_QUEUE_WAIT_FOREVER); 10b7d2: 6a 00 push $0x0 <== NOT EXECUTED 10b7d4: 6a 00 push $0x0 <== NOT EXECUTED 10b7d6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b7d9: e8 32 54 00 00 call 110c10 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10b7de: c9 leave <== NOT EXECUTED 10b7df: c3 ret <== NOT EXECUTED 0010b7e0 : */ int sem_unlink( const char *name ) { 10b7e0: 55 push %ebp <== NOT EXECUTED 10b7e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7e3: 53 push %ebx <== NOT EXECUTED 10b7e4: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b7e7: a1 f0 33 12 00 mov 0x1233f0,%eax <== NOT EXECUTED 10b7ec: 40 inc %eax <== NOT EXECUTED 10b7ed: a3 f0 33 12 00 mov %eax,0x1233f0 <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10b7f2: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b7f5: 50 push %eax <== NOT EXECUTED 10b7f6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b7f9: e8 b2 53 00 00 call 110bb0 <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10b7fe: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10b800: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b803: 85 c0 test %eax,%eax <== NOT EXECUTED 10b805: 74 11 je 10b818 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b807: e8 b0 24 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10b80c: e8 e3 6d 00 00 call 1125f4 <__errno> <== NOT EXECUTED 10b811: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10b813: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b816: eb 3c jmp 10b854 <== NOT EXECUTED } the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object( 10b818: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10b81b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b81d: 66 3b 05 f0 36 12 00 cmp 0x1236f0,%ax <== NOT EXECUTED 10b824: 77 0b ja 10b831 <== NOT EXECUTED * This heap routine returns information about the free blocks * in the specified heap. 10b826: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10b829: a1 fc 36 12 00 mov 0x1236fc,%eax <== NOT EXECUTED 10b82e: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Semaphore_Information, _Objects_Get_index( the_semaphore_id ) ); the_semaphore->linked = FALSE; 10b831: c6 43 15 00 movb $0x0,0x15(%ebx) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10b835: 50 push %eax <== NOT EXECUTED 10b836: 50 push %eax <== NOT EXECUTED 10b837: 53 push %ebx <== NOT EXECUTED 10b838: 68 e0 36 12 00 push $0x1236e0 <== NOT EXECUTED 10b83d: e8 ce 1d 00 00 call 10d610 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 10b842: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b845: e8 1e 53 00 00 call 110b68 <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b84a: e8 6d 24 00 00 call 10dcbc <_Thread_Enable_dispatch> <== NOT EXECUTED 10b84f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b851: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10b854: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b857: c9 leave <== NOT EXECUTED 10b858: c3 ret <== NOT EXECUTED 0010b85c : */ int sem_wait( sem_t *sem ) { 10b85c: 55 push %ebp <== NOT EXECUTED 10b85d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b85f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support( sem, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10b862: 6a 00 push $0x0 <== NOT EXECUTED 10b864: 6a 01 push $0x1 <== NOT EXECUTED 10b866: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b869: e8 a2 53 00 00 call 110c10 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10b86e: c9 leave <== NOT EXECUTED 10b86f: c3 ret <== NOT EXECUTED 0011f619 : */ int setgid( gid_t gid ) { 11f619: 55 push %ebp <== NOT EXECUTED 11f61a: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 11f61c: 8b 15 a4 4b 14 00 mov 0x144ba4,%edx <== NOT EXECUTED 11f622: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11f625: 66 89 42 2c mov %ax,0x2c(%edx) <== NOT EXECUTED return 0; } 11f629: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f62b: c9 leave <== NOT EXECUTED 11f62c: c3 ret <== NOT EXECUTED 0011fad4 : return NULL; return &grent; } void setgrent(void) { 11fad4: 55 push %ebp <== NOT EXECUTED 11fad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fad7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 11fada: e8 24 ff ff ff call 11fa03 <== NOT EXECUTED if (group_fp != NULL) 11fadf: a1 ac a2 15 00 mov 0x15a2ac,%eax <== NOT EXECUTED 11fae4: 85 c0 test %eax,%eax <== NOT EXECUTED 11fae6: 74 0c je 11faf4 <== NOT EXECUTED fclose(group_fp); 11fae8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11faeb: 50 push %eax <== NOT EXECUTED 11faec: e8 a7 ba 00 00 call 12b598 <== NOT EXECUTED 11faf1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 11faf4: 50 push %eax <== NOT EXECUTED 11faf5: 50 push %eax <== NOT EXECUTED 11faf6: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fafb: 68 08 dd 13 00 push $0x13dd08 <== NOT EXECUTED 11fb00: e8 ff c1 00 00 call 12bd04 <== NOT EXECUTED 11fb05: a3 ac a2 15 00 mov %eax,0x15a2ac <== NOT EXECUTED 11fb0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11fb0d: c9 leave <== NOT EXECUTED 11fb0e: c3 ret <== NOT EXECUTED 0011fc70 : return NULL; return &pwent; } void setpwent(void) { 11fc70: 55 push %ebp <== NOT EXECUTED 11fc71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc73: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 11fc76: e8 88 fd ff ff call 11fa03 <== NOT EXECUTED if (passwd_fp != NULL) 11fc7b: a1 c4 a1 15 00 mov 0x15a1c4,%eax <== NOT EXECUTED 11fc80: 85 c0 test %eax,%eax <== NOT EXECUTED 11fc82: 74 0c je 11fc90 <== NOT EXECUTED fclose(passwd_fp); 11fc84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11fc87: 50 push %eax <== NOT EXECUTED 11fc88: e8 0b b9 00 00 call 12b598 <== NOT EXECUTED 11fc8d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 11fc90: 50 push %eax <== NOT EXECUTED 11fc91: 50 push %eax <== NOT EXECUTED 11fc92: 68 f2 bf 13 00 push $0x13bff2 <== NOT EXECUTED 11fc97: 68 95 dc 13 00 push $0x13dc95 <== NOT EXECUTED 11fc9c: e8 63 c0 00 00 call 12bd04 <== NOT EXECUTED 11fca1: a3 c4 a1 15 00 mov %eax,0x15a1c4 <== NOT EXECUTED 11fca6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11fca9: c9 leave <== NOT EXECUTED 11fcaa: 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 a4 4b 14 00 mov 0x144ba4,%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 00109644 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 109644: 55 push %ebp <== NOT EXECUTED 109645: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109647: 57 push %edi <== NOT EXECUTED 109648: 56 push %esi <== NOT EXECUTED 109649: 53 push %ebx <== NOT EXECUTED 10964a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10964d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109650: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED ISR_Level level; if ( oact ) 109653: 85 ff test %edi,%edi <== NOT EXECUTED 109655: 74 10 je 109667 <== NOT EXECUTED *oact = _POSIX_signals_Vectors[ sig ]; 109657: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 10965a: 8d b0 7c 05 12 00 lea 0x12057c(%eax),%esi <== NOT EXECUTED 109660: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 109665: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !sig ) 109667: 85 db test %ebx,%ebx <== NOT EXECUTED 109669: 74 0d je 109678 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10966b: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED 10966e: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 109671: 77 05 ja 109678 <== NOT EXECUTED * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 109673: 83 fb 09 cmp $0x9,%ebx <== NOT EXECUTED 109676: 75 10 jne 109688 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109678: e8 33 68 00 00 call 10feb0 <__errno> <== NOT EXECUTED 10967d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109683: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109686: eb 5a jmp 1096e2 <== NOT EXECUTED /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 109688: 31 c0 xor %eax,%eax <== NOT EXECUTED 10968a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10968e: 74 52 je 1096e2 <== NOT EXECUTED /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 109690: 9c pushf <== NOT EXECUTED 109691: fa cli <== NOT EXECUTED 109692: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( act->sa_handler == SIG_DFL ) { 109695: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109698: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED 10969c: 75 18 jne 1096b6 <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10969e: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 1096a1: 8d b8 7c 05 12 00 lea 0x12057c(%eax),%edi <== NOT EXECUTED 1096a7: 8d b0 c4 9d 11 00 lea 0x119dc4(%eax),%esi <== NOT EXECUTED 1096ad: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 1096b2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1096b4: eb 26 jmp 1096dc <== NOT EXECUTED } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 1096b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1096b9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 1096be: d3 e0 shl %cl,%eax <== NOT EXECUTED 1096c0: 50 push %eax <== NOT EXECUTED 1096c1: e8 e2 4d 00 00 call 10e4a8 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = *act; 1096c6: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 1096c9: 8d b8 7c 05 12 00 lea 0x12057c(%eax),%edi <== NOT EXECUTED 1096cf: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 1096d4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1096d7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1096d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 1096dc: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1096df: 9d popf <== NOT EXECUTED 1096e0: 31 c0 xor %eax,%eax <== NOT EXECUTED * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 1096e2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1096e5: 5b pop %ebx <== NOT EXECUTED 1096e6: 5e pop %esi <== NOT EXECUTED 1096e7: 5f pop %edi <== NOT EXECUTED 1096e8: c9 leave <== NOT EXECUTED 1096e9: c3 ret <== NOT EXECUTED 001096ec : int sigaddset( sigset_t *set, int signo ) { 1096ec: 55 push %ebp <== NOT EXECUTED 1096ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1096ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1096f2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1096f5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 1096f8: 85 d2 test %edx,%edx <== NOT EXECUTED 1096fa: 74 0c je 109708 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 1096fc: 85 c0 test %eax,%eax <== NOT EXECUTED 1096fe: 74 08 je 109708 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(signo) ) 109700: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 109703: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 109706: 76 10 jbe 109718 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109708: e8 a3 67 00 00 call 10feb0 <__errno> <== NOT EXECUTED 10970d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109713: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109716: eb 0b jmp 109723 <== NOT EXECUTED *set |= signo_to_mask(signo); 109718: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10971d: d3 e0 shl %cl,%eax <== NOT EXECUTED 10971f: 09 02 or %eax,(%edx) <== NOT EXECUTED 109721: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 109723: c9 leave <== NOT EXECUTED 109724: c3 ret <== NOT EXECUTED 0010b0f8 : int sigdelset( sigset_t *set, int signo ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0fe: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b101: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !set ) 10b104: 85 d2 test %edx,%edx <== NOT EXECUTED 10b106: 74 0c je 10b114 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10b108: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b10a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b10c: 74 21 je 10b12f <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10b10e: 49 dec %ecx <== NOT EXECUTED 10b10f: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10b112: 76 10 jbe 10b124 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10b114: e8 97 6c 00 00 call 111db0 <__errno> <== NOT EXECUTED 10b119: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b11f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b122: eb 0b jmp 10b12f <== NOT EXECUTED *set &= ~signo_to_mask(signo); 10b124: b8 fe ff ff ff mov $0xfffffffe,%eax <== NOT EXECUTED 10b129: d3 c0 rol %cl,%eax <== NOT EXECUTED 10b12b: 21 02 and %eax,(%edx) <== NOT EXECUTED 10b12d: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b12f: c9 leave <== NOT EXECUTED 10b130: c3 ret <== NOT EXECUTED 0010d8a4 : #include int sigemptyset( sigset_t *set ) { 10d8a4: 55 push %ebp <== NOT EXECUTED 10d8a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8a7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d8aa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10d8ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8af: 75 10 jne 10d8c1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10d8b1: e8 02 18 00 00 call 10f0b8 <__errno> <== NOT EXECUTED 10d8b6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d8bc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d8bf: eb 08 jmp 10d8c9 <== NOT EXECUTED *set = 0; 10d8c1: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10d8c7: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10d8c9: c9 leave <== NOT EXECUTED 10d8ca: c3 ret <== NOT EXECUTED 0010b15c : #include int sigfillset( sigset_t *set ) { 10b15c: 55 push %ebp <== NOT EXECUTED 10b15d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b15f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b162: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10b165: 85 c0 test %eax,%eax <== NOT EXECUTED 10b167: 75 10 jne 10b179 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10b169: e8 42 6c 00 00 call 111db0 <__errno> <== NOT EXECUTED 10b16e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b174: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b177: eb 08 jmp 10b181 <== NOT EXECUTED *set = SIGNAL_ALL_MASK; 10b179: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 10b17f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b181: c9 leave <== NOT EXECUTED 10b182: c3 ret <== NOT EXECUTED 0010b184 : int sigismember( const sigset_t *set, int signo ) { 10b184: 55 push %ebp <== NOT EXECUTED 10b185: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b187: 53 push %ebx <== NOT EXECUTED 10b188: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b18b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b18e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !set ) 10b191: 85 db test %ebx,%ebx <== NOT EXECUTED 10b193: 74 0e je 10b1a3 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10b195: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b197: 85 d2 test %edx,%edx <== NOT EXECUTED 10b199: 74 27 je 10b1c2 <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10b19b: 8d 4a ff lea -0x1(%edx),%ecx <== NOT EXECUTED 10b19e: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10b1a1: 76 10 jbe 10b1b3 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10b1a3: e8 08 6c 00 00 call 111db0 <__errno> <== NOT EXECUTED 10b1a8: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b1ae: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b1b1: eb 0f jmp 10b1c2 <== NOT EXECUTED 10b1b3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b1b8: d3 e0 shl %cl,%eax <== NOT EXECUTED 10b1ba: 85 03 test %eax,(%ebx) <== NOT EXECUTED 10b1bc: 0f 95 c0 setne %al <== NOT EXECUTED 10b1bf: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED if ( *set & signo_to_mask(signo) ) return 1; return 0; } 10b1c2: 5a pop %edx <== NOT EXECUTED 10b1c3: 5b pop %ebx <== NOT EXECUTED 10b1c4: c9 leave <== NOT EXECUTED 10b1c5: c3 ret <== NOT EXECUTED 001093ac : sighandler_t signal( int signum, sighandler_t handler ) { 1093ac: 55 push %ebp <== NOT EXECUTED 1093ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1093af: 53 push %ebx <== NOT EXECUTED 1093b0: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED struct sigaction s; struct sigaction old; s.sa_handler = handler ; 1093b3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1093b6: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED sigemptyset(&s.sa_mask); 1093b9: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 1093bc: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1093bf: 50 push %eax <== NOT EXECUTED 1093c0: e8 bf ff ff ff call 109384 <== NOT EXECUTED s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0; 1093c5: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED #endif sigaction( signum, &s, &old ); 1093cc: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1093cf: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1093d2: 50 push %eax <== NOT EXECUTED 1093d3: 53 push %ebx <== NOT EXECUTED 1093d4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1093d7: e8 c4 fe ff ff call 1092a0 <== NOT EXECUTED 1093dc: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED return (sighandler_t) old.sa_handler; } 1093df: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1093e2: c9 leave <== NOT EXECUTED 1093e3: c3 ret <== NOT EXECUTED 00109750 : #include int sigpending( sigset_t *set ) { 109750: 55 push %ebp <== NOT EXECUTED 109751: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109753: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109756: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; if ( !set ) 109759: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10975b: 75 10 jne 10976d <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10975d: e8 4e 67 00 00 call 10feb0 <__errno> <== NOT EXECUTED 109762: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109768: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10976b: eb 1a jmp 109787 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; *set = api->signals_pending | _POSIX_signals_Pending; 10976d: a1 98 00 12 00 mov 0x120098,%eax <== NOT EXECUTED 109772: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 109778: a1 48 07 12 00 mov 0x120748,%eax <== NOT EXECUTED 10977d: 0b 82 c8 00 00 00 or 0xc8(%edx),%eax <== NOT EXECUTED 109783: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 109785: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 109787: c9 leave <== NOT EXECUTED 109788: c3 ret <== NOT EXECUTED 0010978c : int sigprocmask( int how, const sigset_t *set, sigset_t *oset ) { 10978c: 55 push %ebp <== NOT EXECUTED 10978d: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); } 10978f: c9 leave <== NOT EXECUTED { /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); 109790: e9 a3 50 00 00 jmp 10e838 <== NOT EXECUTED 0010b210 : int sigqueue( pid_t pid, int signo, const union sigval value ) { 10b210: 55 push %ebp <== NOT EXECUTED 10b211: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b213: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, signo, &value ); 10b216: 8d 45 10 lea 0x10(%ebp),%eax <== NOT EXECUTED 10b219: 50 push %eax <== NOT EXECUTED 10b21a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b21d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b220: e8 13 4e 00 00 call 110038 <== NOT EXECUTED } 10b225: c9 leave <== NOT EXECUTED 10b226: c3 ret <== NOT EXECUTED 0010b228 : #include int sigsuspend( const sigset_t *sigmask ) { 10b228: 55 push %ebp <== NOT EXECUTED 10b229: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b22b: 56 push %esi <== NOT EXECUTED 10b22c: 53 push %ebx <== NOT EXECUTED 10b22d: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED int status; POSIX_API_Control *api; api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 10b230: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10b233: 53 push %ebx <== NOT EXECUTED 10b234: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b237: 6a 01 push $0x1 <== NOT EXECUTED 10b239: e8 c6 ff ff ff call 10b204 <== NOT EXECUTED (void) sigfillset( &all_signals ); 10b23e: 8d 75 f0 lea -0x10(%ebp),%esi <== NOT EXECUTED 10b241: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b244: e8 13 ff ff ff call 10b15c <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10b249: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b24c: 6a 00 push $0x0 <== NOT EXECUTED 10b24e: 6a 00 push $0x0 <== NOT EXECUTED 10b250: 56 push %esi <== NOT EXECUTED 10b251: e8 6b 00 00 00 call 10b2c1 <== NOT EXECUTED 10b256: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 10b258: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b25b: 6a 00 push $0x0 <== NOT EXECUTED 10b25d: 53 push %ebx <== NOT EXECUTED 10b25e: 6a 00 push $0x0 <== NOT EXECUTED 10b260: e8 9f ff ff ff call 10b204 <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) 10b265: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b268: 46 inc %esi <== NOT EXECUTED 10b269: 74 0b je 10b276 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); 10b26b: e8 40 6b 00 00 call 111db0 <__errno> <== NOT EXECUTED 10b270: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED return status; } 10b276: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10b279: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b27c: 5b pop %ebx <== NOT EXECUTED 10b27d: 5e pop %esi <== NOT EXECUTED 10b27e: c9 leave <== NOT EXECUTED 10b27f: c3 ret <== NOT EXECUTED 00109a11 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 109a11: 55 push %ebp <== NOT EXECUTED 109a12: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a14: 57 push %edi <== NOT EXECUTED 109a15: 56 push %esi <== NOT EXECUTED 109a16: 53 push %ebx <== NOT EXECUTED 109a17: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109a1a: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 109a1d: 85 db test %ebx,%ebx <== NOT EXECUTED 109a1f: 74 35 je 109a56 <== NOT EXECUTED if ( !_Timespec_Is_valid( timeout ) ) 109a21: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a24: 53 push %ebx <== NOT EXECUTED 109a25: e8 92 31 00 00 call 10cbbc <_Timespec_Is_valid> <== NOT EXECUTED 109a2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a2d: 84 c0 test %al,%al <== NOT EXECUTED 109a2f: 74 12 je 109a43 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 109a31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a34: 53 push %ebx <== NOT EXECUTED 109a35: e8 de 31 00 00 call 10cc18 <_Timespec_To_ticks> <== NOT EXECUTED 109a3a: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !interval ) 109a3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a3f: 85 c0 test %eax,%eax <== NOT EXECUTED 109a41: 75 15 jne 109a58 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109a43: e8 d8 69 00 00 call 110420 <__errno> <== NOT EXECUTED 109a48: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109a4e: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 109a51: e9 05 01 00 00 jmp 109b5b <== NOT EXECUTED 109a56: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 109a58: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109a5b: 85 f6 test %esi,%esi <== NOT EXECUTED 109a5d: 75 03 jne 109a62 <== NOT EXECUTED 109a5f: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED the_thread = _Thread_Executing; 109a62: 8b 15 d8 06 12 00 mov 0x1206d8,%edx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109a68: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi <== NOT EXECUTED * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 109a6e: 9c pushf <== NOT EXECUTED 109a6f: fa cli <== NOT EXECUTED 109a70: 8f 45 e0 popl -0x20(%ebp) <== NOT EXECUTED if ( *set & api->signals_pending ) { 109a73: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109a76: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 109a78: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax <== NOT EXECUTED 109a7e: 85 c1 test %eax,%ecx <== NOT EXECUTED 109a80: 74 2c je 109aae <== NOT EXECUTED /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 109a82: 50 push %eax <== NOT EXECUTED 109a83: e8 48 ff ff ff call 1099d0 <_POSIX_signals_Get_highest> <== NOT EXECUTED 109a88: 89 06 mov %eax,(%esi) <== NOT EXECUTED _POSIX_signals_Clear_signals( 109a8a: 51 push %ecx <== NOT EXECUTED 109a8b: 51 push %ecx <== NOT EXECUTED 109a8c: 6a 00 push $0x0 <== NOT EXECUTED 109a8e: 6a 00 push $0x0 <== NOT EXECUTED 109a90: 56 push %esi <== NOT EXECUTED 109a91: 50 push %eax <== NOT EXECUTED 109a92: 57 push %edi <== NOT EXECUTED 109a93: e8 00 50 00 00 call 10ea98 <_POSIX_signals_Clear_signals> <== NOT EXECUTED the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 109a98: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 109a9b: 9d popf <== NOT EXECUTED the_info->si_code = SI_USER; 109a9c: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 109aa3: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED return the_info->si_signo; 109aaa: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 109aac: eb 33 jmp 109ae1 <== NOT EXECUTED } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 109aae: a1 88 0d 12 00 mov 0x120d88,%eax <== NOT EXECUTED 109ab3: 85 c1 test %eax,%ecx <== NOT EXECUTED 109ab5: 74 2f je 109ae6 <== NOT EXECUTED signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 109ab7: 50 push %eax <== NOT EXECUTED 109ab8: e8 13 ff ff ff call 1099d0 <_POSIX_signals_Get_highest> <== NOT EXECUTED 109abd: 89 c3 mov %eax,%ebx <== NOT EXECUTED _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 109abf: 52 push %edx <== NOT EXECUTED 109ac0: 52 push %edx <== NOT EXECUTED 109ac1: 6a 00 push $0x0 <== NOT EXECUTED 109ac3: 6a 01 push $0x1 <== NOT EXECUTED 109ac5: 56 push %esi <== NOT EXECUTED 109ac6: 50 push %eax <== NOT EXECUTED 109ac7: 57 push %edi <== NOT EXECUTED 109ac8: e8 cb 4f 00 00 call 10ea98 <_POSIX_signals_Clear_signals> <== NOT EXECUTED _ISR_Enable( level ); 109acd: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 109ad0: 9d popf <== NOT EXECUTED the_info->si_signo = signo; 109ad1: 89 1e mov %ebx,(%esi) <== NOT EXECUTED the_info->si_code = SI_USER; 109ad3: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 109ada: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED 109ae1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109ae4: eb 75 jmp 109b5b <== NOT EXECUTED return signo; } the_info->si_signo = -1; 109ae6: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109aec: a1 18 06 12 00 mov 0x120618,%eax <== NOT EXECUTED 109af1: 40 inc %eax <== NOT EXECUTED 109af2: a3 18 06 12 00 mov %eax,0x120618 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 109af7: c7 42 44 48 0d 12 00 movl $0x120d48,0x44(%edx) <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 109afe: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) <== NOT EXECUTED the_thread->Wait.option = *set; 109b05: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109b08: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 109b0a: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED the_thread->Wait.return_argument = the_info; 109b0d: 89 72 28 mov %esi,0x28(%edx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109b10: c7 05 78 0d 12 00 01 movl $0x1,0x120d78 <== NOT EXECUTED 109b17: 00 00 00 <== NOT EXECUTED _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 109b1a: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 109b1d: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 109b1e: 50 push %eax <== NOT EXECUTED 109b1f: 68 b8 c7 10 00 push $0x10c7b8 <== NOT EXECUTED 109b24: 53 push %ebx <== NOT EXECUTED 109b25: 68 48 0d 12 00 push $0x120d48 <== NOT EXECUTED 109b2a: e8 85 29 00 00 call 10c4b4 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 109b2f: e8 30 25 00 00 call 10c064 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 109b34: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 109b3b: 6a 00 push $0x0 <== NOT EXECUTED 109b3d: 56 push %esi <== NOT EXECUTED 109b3e: ff 36 pushl (%esi) <== NOT EXECUTED 109b40: 57 push %edi <== NOT EXECUTED 109b41: e8 52 4f 00 00 call 10ea98 <_POSIX_signals_Clear_signals> <== NOT EXECUTED errno = _Thread_Executing->Wait.return_code; 109b46: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109b49: e8 d2 68 00 00 call 110420 <__errno> <== NOT EXECUTED 109b4e: 8b 15 d8 06 12 00 mov 0x1206d8,%edx <== NOT EXECUTED 109b54: 8b 52 34 mov 0x34(%edx),%edx <== NOT EXECUTED 109b57: 89 10 mov %edx,(%eax) <== NOT EXECUTED return the_info->si_signo; 109b59: 8b 1e mov (%esi),%ebx <== NOT EXECUTED } 109b5b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109b5d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109b60: 5b pop %ebx <== NOT EXECUTED 109b61: 5e pop %esi <== NOT EXECUTED 109b62: 5f pop %edi <== NOT EXECUTED 109b63: c9 leave <== NOT EXECUTED 109b64: c3 ret <== NOT EXECUTED 0010b430 : int sigwait( const sigset_t *set, int *sig ) { 10b430: 55 push %ebp <== NOT EXECUTED 10b431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b433: 53 push %ebx <== NOT EXECUTED 10b434: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b437: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED int status; status = sigtimedwait( set, NULL, NULL ); 10b43a: 6a 00 push $0x0 <== NOT EXECUTED 10b43c: 6a 00 push $0x0 <== NOT EXECUTED 10b43e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b441: e8 7b fe ff ff call 10b2c1 <== NOT EXECUTED 10b446: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( status != -1 ) { 10b448: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b44b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10b44e: 74 0c je 10b45c <== NOT EXECUTED if ( sig ) 10b450: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b452: 85 db test %ebx,%ebx <== NOT EXECUTED 10b454: 74 0d je 10b463 <== NOT EXECUTED *sig = status; 10b456: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10b458: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b45a: eb 07 jmp 10b463 <== NOT EXECUTED return 0; } return errno; 10b45c: e8 4f 69 00 00 call 111db0 <__errno> <== NOT EXECUTED 10b461: 8b 00 mov (%eax),%eax <== NOT EXECUTED } 10b463: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b466: c9 leave <== NOT EXECUTED 10b467: c3 ret <== NOT EXECUTED 0010b418 : int sigwaitinfo( const sigset_t *set, siginfo_t *info ) { 10b418: 55 push %ebp <== NOT EXECUTED 10b419: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b41b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return sigtimedwait( set, info, NULL ); 10b41e: 6a 00 push $0x0 <== NOT EXECUTED 10b420: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b423: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b426: e8 96 fe ff ff call 10b2c1 <== NOT EXECUTED } 10b42b: c9 leave <== NOT EXECUTED 10b42c: 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 00108b08 : unsigned int sleep( unsigned int seconds ) { 108b08: 55 push %ebp <== NOT EXECUTED 108b09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b0b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED struct timespec tp; struct timespec tm; tp.tv_sec = seconds; 108b0e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108b11: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tp.tv_nsec = 0; 108b14: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 108b1b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108b1e: 50 push %eax <== NOT EXECUTED 108b1f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 108b22: 50 push %eax <== NOT EXECUTED 108b23: e8 9c 4c 00 00 call 10d7c4 <== NOT EXECUTED 108b28: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED return tm.tv_sec; /* seconds remaining */ } 108b2b: c9 leave <== NOT EXECUTED 108b2c: 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 ac 00 02 00 call 12b44c <__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 65 00 02 00 call 12b44c <__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 001207e4 : int symlink( const char *actualpath, const char *sympath ) { 1207e4: 55 push %ebp <== NOT EXECUTED 1207e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1207e7: 57 push %edi <== NOT EXECUTED 1207e8: 56 push %esi <== NOT EXECUTED 1207e9: 53 push %ebx <== NOT EXECUTED 1207ea: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1207ed: 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 ); 1207f0: 8a 03 mov (%ebx),%al <== NOT EXECUTED 1207f2: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 1207f4: 74 08 je 1207fe <== NOT EXECUTED 1207f6: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 1207f8: 74 04 je 1207fe <== NOT EXECUTED 1207fa: 84 c0 test %al,%al <== NOT EXECUTED 1207fc: 75 19 jne 120817 <== NOT EXECUTED 1207fe: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 120801: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 120806: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 120809: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12080e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 120810: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 120815: eb 14 jmp 12082b <== NOT EXECUTED 120817: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 12081a: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 12081f: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 120822: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 120827: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 120829: 31 d2 xor %edx,%edx <== NOT EXECUTED result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 12082b: 51 push %ecx <== NOT EXECUTED 12082c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12082f: 50 push %eax <== NOT EXECUTED 120830: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 120833: 57 push %edi <== NOT EXECUTED 120834: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 120837: 50 push %eax <== NOT EXECUTED 120838: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 12083b: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( result != 0 ) 12083e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120841: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 120844: 85 c0 test %eax,%eax <== NOT EXECUTED 120846: 75 50 jne 120898 <== NOT EXECUTED return -1; if ( !loc.ops->symlink_h ) { 120848: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 12084b: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 12084e: 85 d2 test %edx,%edx <== NOT EXECUTED 120850: 75 20 jne 120872 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120852: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120855: 85 c0 test %eax,%eax <== NOT EXECUTED 120857: 74 09 je 120862 <== NOT EXECUTED 120859: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12085c: 57 push %edi <== NOT EXECUTED 12085d: ff d0 call *%eax <== NOT EXECUTED 12085f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 120862: e8 e5 ab 00 00 call 12b44c <__errno> <== NOT EXECUTED 120867: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12086d: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 120870: eb 26 jmp 120898 <== NOT EXECUTED } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 120872: 50 push %eax <== NOT EXECUTED 120873: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 120876: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120879: 57 push %edi <== NOT EXECUTED 12087a: ff d2 call *%edx <== NOT EXECUTED 12087c: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12087e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120881: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120884: 85 c0 test %eax,%eax <== NOT EXECUTED 120886: 74 10 je 120898 <== NOT EXECUTED 120888: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12088b: 85 c0 test %eax,%eax <== NOT EXECUTED 12088d: 74 09 je 120898 <== NOT EXECUTED 12088f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120892: 57 push %edi <== NOT EXECUTED 120893: ff d0 call *%eax <== NOT EXECUTED 120895: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120898: 89 f0 mov %esi,%eax <== NOT EXECUTED 12089a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12089d: 5b pop %ebx <== NOT EXECUTED 12089e: 5e pop %esi <== NOT EXECUTED 12089f: 5f pop %edi <== NOT EXECUTED 1208a0: c9 leave <== NOT EXECUTED 1208a1: c3 ret <== NOT EXECUTED 0010847a : * We have to extern it here. */ extern struct _reent libc_global_reent; void sync(void) { 10847a: 55 push %ebp <== NOT EXECUTED 10847b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10847d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Walk the one used initially by RTEMS. */ _fwalk(&libc_global_reent, sync_wrapper); 108480: 68 a0 84 10 00 push $0x1084a0 <== NOT EXECUTED 108485: 68 98 ef 11 00 push $0x11ef98 <== NOT EXECUTED 10848a: e8 81 97 00 00 call 111c10 <_fwalk> <== NOT EXECUTED */ /* * Now walk all the per-thread reentrancy structures. */ rtems_iterate_over_all_threads(sync_per_thread); 10848f: c7 04 24 30 84 10 00 movl $0x108430,(%esp) <== NOT EXECUTED 108496: e8 8d 32 00 00 call 10b728 <== NOT EXECUTED 10849b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10849e: c9 leave <== NOT EXECUTED 10849f: c3 ret <== NOT EXECUTED 00108430 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 108430: 55 push %ebp <== NOT EXECUTED 108431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108433: 53 push %ebx <== NOT EXECUTED 108434: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 108437: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent; 10843a: 8b 91 f0 00 00 00 mov 0xf0(%ecx),%edx <== NOT EXECUTED if ( this_reent ) { 108440: 85 d2 test %edx,%edx <== NOT EXECUTED 108442: 74 31 je 108475 <== NOT EXECUTED current_reent = _Thread_Executing->libc_reent; 108444: a1 88 15 12 00 mov 0x121588,%eax <== NOT EXECUTED 108449: 8b 98 f0 00 00 00 mov 0xf0(%eax),%ebx <== NOT EXECUTED _Thread_Executing->libc_reent = this_reent; 10844f: 89 90 f0 00 00 00 mov %edx,0xf0(%eax) <== NOT EXECUTED _fwalk (t->libc_reent, sync_wrapper); 108455: 50 push %eax <== NOT EXECUTED 108456: 50 push %eax <== NOT EXECUTED 108457: 68 a0 84 10 00 push $0x1084a0 <== NOT EXECUTED 10845c: ff b1 f0 00 00 00 pushl 0xf0(%ecx) <== NOT EXECUTED 108462: e8 a9 97 00 00 call 111c10 <_fwalk> <== NOT EXECUTED _Thread_Executing->libc_reent = current_reent; 108467: a1 88 15 12 00 mov 0x121588,%eax <== NOT EXECUTED 10846c: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax) <== NOT EXECUTED 108472: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 108475: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108478: c9 leave <== NOT EXECUTED 108479: c3 ret <== NOT EXECUTED 001084a0 : /* XXX check standards -- Linux version appears to be void */ void _fwalk(struct _reent *, void *); static void sync_wrapper(FILE *f) { 1084a0: 55 push %ebp <== NOT EXECUTED 1084a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1084a3: 53 push %ebx <== NOT EXECUTED 1084a4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED int fn = fileno(f); 1084a7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1084aa: e8 e5 8d 00 00 call 111294 <== NOT EXECUTED 1084af: 89 c3 mov %eax,%ebx <== NOT EXECUTED fsync(fn); 1084b1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1084b4: e8 5f ef ff ff call 107418 <== NOT EXECUTED fdatasync(fn); 1084b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1084bc: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 1084bf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1084c2: c9 leave <== NOT EXECUTED static void sync_wrapper(FILE *f) { int fn = fileno(f); fsync(fn); fdatasync(fn); 1084c3: e9 3c ed ff ff jmp 107204 <== NOT EXECUTED 00108b1c : */ long sysconf( int name ) { 108b1c: 55 push %ebp <== NOT EXECUTED 108b1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b1f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108b22: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED switch (name) { 108b25: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 108b28: 74 2d je 108b57 <== NOT EXECUTED 108b2a: 7f 07 jg 108b33 <== NOT EXECUTED 108b2c: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 108b2f: 75 2d jne 108b5e <== NOT EXECUTED 108b31: eb 15 jmp 108b48 <== NOT EXECUTED 108b33: b8 00 10 00 00 mov $0x1000,%eax <== NOT EXECUTED 108b38: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 108b3b: 74 2f je 108b6c <== NOT EXECUTED 108b3d: 66 b8 00 04 mov $0x400,%ax <== NOT EXECUTED 108b41: 83 fa 33 cmp $0x33,%edx <== NOT EXECUTED 108b44: 75 18 jne 108b5e <== NOT EXECUTED 108b46: eb 24 jmp 108b6c <== NOT EXECUTED case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); 108b48: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 108b4d: 31 d2 xor %edx,%edx <== NOT EXECUTED 108b4f: f7 35 84 f6 11 00 divl 0x11f684 <== NOT EXECUTED 108b55: eb 15 jmp 108b6c <== NOT EXECUTED case _SC_OPEN_MAX: { return rtems_libio_number_iops; 108b57: a1 38 b0 11 00 mov 0x11b038,%eax <== NOT EXECUTED 108b5c: eb 0e jmp 108b6c <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 108b5e: e8 d5 69 00 00 call 10f538 <__errno> <== NOT EXECUTED 108b63: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 108b69: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 108b6c: c9 leave <== NOT EXECUTED 108b6d: c3 ret <== NOT EXECUTED 001208a4 : #include int tcdrain( int fd ) { 1208a4: 55 push %ebp <== NOT EXECUTED 1208a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1208a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_TCDRAIN, 0 ); 1208aa: 6a 00 push $0x0 <== NOT EXECUTED 1208ac: 6a 03 push $0x3 <== NOT EXECUTED 1208ae: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1208b1: e8 56 f5 ff ff call 11fe0c <== NOT EXECUTED } 1208b6: c9 leave <== NOT EXECUTED 1208b7: c3 ret <== NOT EXECUTED 00112308 : int tcgetattr( int fd, struct termios *tp ) { 112308: 55 push %ebp <== NOT EXECUTED 112309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11230b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 11230e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112311: 6a 01 push $0x1 <== NOT EXECUTED 112313: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112316: e8 41 30 00 00 call 11535c <== NOT EXECUTED } 11231b: c9 leave <== NOT EXECUTED 11231c: c3 ret <== NOT EXECUTED 00112320 : int tcsetattr( int fd, int opt, struct termios *tp ) { 112320: 55 push %ebp <== NOT EXECUTED 112321: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112323: 56 push %esi <== NOT EXECUTED 112324: 53 push %ebx <== NOT EXECUTED 112325: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 112328: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11232b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED switch (opt) { 11232e: 85 c0 test %eax,%eax <== NOT EXECUTED 112330: 74 22 je 112354 <== NOT EXECUTED 112332: 48 dec %eax <== NOT EXECUTED 112333: 74 0d je 112342 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 112335: e8 02 39 00 00 call 115c3c <__errno> <== NOT EXECUTED 11233a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 112340: eb 2a jmp 11236c <== NOT EXECUTED case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 112342: 50 push %eax <== NOT EXECUTED 112343: 6a 00 push $0x0 <== NOT EXECUTED 112345: 6a 03 push $0x3 <== NOT EXECUTED 112347: 53 push %ebx <== NOT EXECUTED 112348: e8 0f 30 00 00 call 11535c <== NOT EXECUTED 11234d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112350: 85 c0 test %eax,%eax <== NOT EXECUTED 112352: 78 18 js 11236c <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 112354: 89 75 10 mov %esi,0x10(%ebp) <== NOT EXECUTED 112357: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) <== NOT EXECUTED 11235e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 112361: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112364: 5b pop %ebx <== NOT EXECUTED 112365: 5e pop %esi <== NOT EXECUTED 112366: c9 leave <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 112367: e9 f0 2f 00 00 jmp 11535c <== NOT EXECUTED } } 11236c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11236f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112372: 5b pop %ebx <== NOT EXECUTED 112373: 5e pop %esi <== NOT EXECUTED 112374: c9 leave <== NOT EXECUTED 112375: c3 ret <== NOT EXECUTED 001090c0 : #include long telldir( DIR *dirp ) { 1090c0: 55 push %ebp <== NOT EXECUTED 1090c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1090c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; if ( !dirp ) 1090c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1090cb: 75 10 jne 1090dd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 1090cd: e8 a6 8c 00 00 call 111d78 <__errno> <== NOT EXECUTED 1090d2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1090d8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1090db: eb 2e jmp 10910b <== NOT EXECUTED /* * Get the file control block structure associated with the * file descriptor */ iop = rtems_libio_iop( dirp->dd_fd ); 1090dd: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1090df: 3b 05 f8 e0 11 00 cmp 0x11e0f8,%eax <== NOT EXECUTED 1090e5: 73 0b jae 1090f2 <== NOT EXECUTED 1090e7: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED if (iop == NULL) 1090ea: 03 05 f8 24 12 00 add 0x1224f8,%eax <== NOT EXECUTED 1090f0: 75 16 jne 109108 <== NOT EXECUTED assert(0); 1090f2: 68 ef b5 11 00 push $0x11b5ef <== NOT EXECUTED 1090f7: 68 f0 bd 11 00 push $0x11bdf0 <== NOT EXECUTED 1090fc: 6a 2c push $0x2c <== NOT EXECUTED 1090fe: 68 a3 bd 11 00 push $0x11bda3 <== NOT EXECUTED 109103: e8 1c e4 ff ff call 107524 <__assert_func> <== NOT EXECUTED return (long)( iop->offset ); 109108: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED } 10910b: c9 leave <== NOT EXECUTED 10910c: 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 0010d4e0 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10d4e0: 55 push %ebp <== NOT EXECUTED 10d4e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d4e3: 57 push %edi <== NOT EXECUTED 10d4e4: 56 push %esi <== NOT EXECUTED 10d4e5: 53 push %ebx <== NOT EXECUTED 10d4e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d4e9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d4ec: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10d4ef: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10d4f3: 75 1d jne 10d512 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10d4f5: 85 ff test %edi,%edi <== NOT EXECUTED 10d4f7: 74 19 je 10d512 <== NOT EXECUTED /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10d4f9: 85 f6 test %esi,%esi <== NOT EXECUTED 10d4fb: 74 22 je 10d51f <== NOT EXECUTED /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10d4fd: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10d4ff: 48 dec %eax <== NOT EXECUTED 10d500: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10d503: 77 0d ja 10d512 <== NOT EXECUTED ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10d505: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10d508: 85 c0 test %eax,%eax <== NOT EXECUTED 10d50a: 74 06 je 10d512 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10d50c: 48 dec %eax <== NOT EXECUTED 10d50d: 83 f8 1f cmp $0x1f,%eax <== NOT EXECUTED 10d510: 76 0d jbe 10d51f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10d512: e8 99 6e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10d517: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d51d: eb 31 jmp 10d550 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d51f: a1 38 62 12 00 mov 0x126238,%eax <== NOT EXECUTED 10d524: 40 inc %eax <== NOT EXECUTED 10d525: a3 38 62 12 00 mov %eax,0x126238 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10d52a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d52d: 68 68 65 12 00 push $0x126568 <== NOT EXECUTED 10d532: e8 81 1b 00 00 call 10f0b8 <_Objects_Allocate> <== NOT EXECUTED 10d537: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10d539: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d53c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d53e: 75 18 jne 10d558 <== NOT EXECUTED _Thread_Enable_dispatch(); 10d540: e8 c3 27 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 10d545: e8 66 6e 00 00 call 1143b0 <__errno> <== NOT EXECUTED 10d54a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10d550: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d553: e9 81 00 00 00 jmp 10d5d9 <== NOT EXECUTED } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10d558: c6 40 3c 02 movb $0x2,0x3c(%eax) <== NOT EXECUTED ptimer->thread_id = _Thread_Executing->Object.id; 10d55c: a1 f8 62 12 00 mov 0x1262f8,%eax <== NOT EXECUTED 10d561: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10d564: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED if ( evp != NULL ) { 10d567: 85 f6 test %esi,%esi <== NOT EXECUTED 10d569: 74 11 je 10d57c <== NOT EXECUTED ptimer->inf.sigev_notify = evp->sigev_notify; 10d56b: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10d56d: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED ptimer->inf.sigev_signo = evp->sigev_signo; 10d570: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10d573: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED ptimer->inf.sigev_value = evp->sigev_value; 10d576: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d579: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED } ptimer->overrun = 0; 10d57c: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_sec = 0; 10d583: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_nsec = 0; 10d58a: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_sec = 0; 10d591: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_nsec = 0; 10d598: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10d59f: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d5a6: 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 10d5ad: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 10d5b4: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 10d5bb: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10d5be: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10d5c1: a1 84 65 12 00 mov 0x126584,%eax <== NOT EXECUTED 10d5c6: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10d5c9: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10d5d0: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10d5d2: e8 31 27 00 00 call 10fd08 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d5d7: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10d5d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d5dc: 5b pop %ebx <== NOT EXECUTED 10d5dd: 5e pop %esi <== NOT EXECUTED 10d5de: 5f pop %edi <== NOT EXECUTED 10d5df: c9 leave <== NOT EXECUTED 10d5e0: c3 ret <== NOT EXECUTED 00109170 : int timer_delete( timer_t timerid ) { 109170: 55 push %ebp <== NOT EXECUTED 109171: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109173: 53 push %ebx <== NOT EXECUTED 109174: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 109177: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10917a: 50 push %eax <== NOT EXECUTED 10917b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10917e: 68 18 08 12 00 push $0x120818 <== NOT EXECUTED 109183: e8 90 1f 00 00 call 10b118 <_Objects_Get> <== NOT EXECUTED 109188: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10918a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10918d: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109191: 75 35 jne 1091c8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); 109193: 51 push %ecx <== NOT EXECUTED 109194: 51 push %ecx <== NOT EXECUTED 109195: 50 push %eax <== NOT EXECUTED 109196: 68 18 08 12 00 push $0x120818 <== NOT EXECUTED 10919b: e8 a8 1b 00 00 call 10ad48 <_Objects_Close> <== NOT EXECUTED ptimer->state = POSIX_TIMER_STATE_FREE; 1091a0: c6 43 3c 01 movb $0x1,0x3c(%ebx) <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 1091a4: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 1091a7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1091aa: e8 85 36 00 00 call 10c834 <_Watchdog_Remove> <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 1091af: 58 pop %eax <== NOT EXECUTED 1091b0: 5a pop %edx <== NOT EXECUTED 1091b1: 53 push %ebx <== NOT EXECUTED 1091b2: 68 18 08 12 00 push $0x120818 <== NOT EXECUTED 1091b7: e8 28 1e 00 00 call 10afe4 <_Objects_Free> <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 1091bc: e8 17 27 00 00 call 10b8d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 1091c1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1091c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1091c6: eb 0e jmp 1091d6 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 1091c8: e8 d3 6e 00 00 call 1100a0 <__errno> <== NOT EXECUTED 1091cd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1091d3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 1091d6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1091d9: c9 leave <== NOT EXECUTED 1091da: c3 ret <== NOT EXECUTED 0010a0a4 : * its execution, _POSIX_Timer_TSR will have to set this counter to 0. */ int timer_getoverrun( timer_t timerid ) { 10a0a4: 55 push %ebp <== NOT EXECUTED 10a0a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0a7: 53 push %ebx <== NOT EXECUTED 10a0a8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 10a0ab: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a0ae: 50 push %eax <== NOT EXECUTED 10a0af: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a0b2: 68 60 1c 12 00 push $0x121c60 <== NOT EXECUTED 10a0b7: e8 24 1f 00 00 call 10bfe0 <_Objects_Get> <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a0bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0bf: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a0c3: 75 11 jne 10a0d6 <== NOT EXECUTED case OBJECTS_LOCAL: overrun = ptimer->overrun; 10a0c5: 8b 58 68 mov 0x68(%eax),%ebx <== NOT EXECUTED ptimer->overrun = 0; 10a0c8: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0cf: e8 cc 26 00 00 call 10c7a0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a0d4: eb 0e jmp 10a0e4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a0d6: e8 39 6b 00 00 call 110c14 <__errno> <== NOT EXECUTED 10a0db: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a0e1: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10a0e4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a0e6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a0e9: c9 leave <== NOT EXECUTED 10a0ea: c3 ret <== NOT EXECUTED 0010a0ec : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10a0ec: 55 push %ebp <== NOT EXECUTED 10a0ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0ef: 56 push %esi <== NOT EXECUTED 10a0f0: 53 push %ebx <== NOT EXECUTED 10a0f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a0f4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; Watchdog_Interval left; if ( !value ) 10a0f7: 85 f6 test %esi,%esi <== NOT EXECUTED 10a0f9: 74 5c je 10a157 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* Reads the current time */ _TOD_Get( ¤t_time ); 10a0fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0fe: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a101: 50 push %eax <== NOT EXECUTED 10a102: e8 49 17 00 00 call 10b850 <_TOD_Get> <== NOT EXECUTED 10a107: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a10a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a10d: 50 push %eax <== NOT EXECUTED 10a10e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a111: 68 60 1c 12 00 push $0x121c60 <== NOT EXECUTED 10a116: e8 c5 1e 00 00 call 10bfe0 <_Objects_Get> <== NOT EXECUTED 10a11b: 89 c3 mov %eax,%ebx <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a11d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a120: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10a124: 75 31 jne 10a157 <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = 10a126: 8b 15 80 1a 12 00 mov 0x121a80,%edx <== NOT EXECUTED (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10a12c: 50 push %eax <== NOT EXECUTED 10a12d: 50 push %eax <== NOT EXECUTED 10a12e: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10a131: 50 push %eax <== NOT EXECUTED 10a132: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a135: 03 43 24 add 0x24(%ebx),%eax <== NOT EXECUTED 10a138: 29 d0 sub %edx,%eax <== NOT EXECUTED 10a13a: 50 push %eax <== NOT EXECUTED 10a13b: e8 b8 31 00 00 call 10d2f8 <_Timespec_From_ticks> <== NOT EXECUTED value->it_interval = ptimer->timer_data.it_interval; 10a140: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED 10a143: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10a146: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10a149: 89 16 mov %edx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a14b: e8 50 26 00 00 call 10c7a0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a150: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a152: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a155: eb 0e jmp 10a165 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a157: e8 b8 6a 00 00 call 110c14 <__errno> <== NOT EXECUTED 10a15c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a162: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10a165: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a168: 5b pop %ebx <== NOT EXECUTED 10a169: 5e pop %esi <== NOT EXECUTED 10a16a: c9 leave <== NOT EXECUTED 10a16b: c3 ret <== NOT EXECUTED 0010a16c : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a16c: 55 push %ebp <== NOT EXECUTED 10a16d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a16f: 57 push %edi <== NOT EXECUTED 10a170: 56 push %esi <== NOT EXECUTED 10a171: 53 push %ebx <== NOT EXECUTED 10a172: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10a175: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a178: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10a17c: 0f 84 4c 01 00 00 je 10a2ce <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* First, it verifies if the structure "value" is correct */ if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) || 10a182: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a185: 81 78 0c ff c9 9a 3b cmpl $0x3b9ac9ff,0xc(%eax) <== NOT EXECUTED 10a18c: 0f 87 3c 01 00 00 ja 10a2ce <== NOT EXECUTED 10a192: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a195: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10a19a: 0f 87 2e 01 00 00 ja 10a2ce <== NOT EXECUTED 10a1a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1a2: 0f 88 26 01 00 00 js 10a2ce <== NOT EXECUTED ( value->it_interval.tv_nsec < 0 )) { /* The number of nanoseconds is not correct */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a1a8: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10a1ab: 74 08 je 10a1b5 <== NOT EXECUTED 10a1ad: 85 d2 test %edx,%edx <== NOT EXECUTED 10a1af: 0f 85 19 01 00 00 jne 10a2ce <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a1b5: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10a1b8: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a1bd: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10a1c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a1c2: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10a1c5: 75 2b jne 10a1f2 <== NOT EXECUTED /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) 10a1c7: 51 push %ecx <== NOT EXECUTED 10a1c8: 51 push %ecx <== NOT EXECUTED 10a1c9: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 10a1cc: 53 push %ebx <== NOT EXECUTED 10a1cd: 68 c0 19 12 00 push $0x1219c0 <== NOT EXECUTED 10a1d2: e8 4d 31 00 00 call 10d324 <_Timespec_Greater_than> <== NOT EXECUTED 10a1d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1da: 84 c0 test %al,%al <== NOT EXECUTED 10a1dc: 0f 85 ec 00 00 00 jne 10a2ce <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); 10a1e2: 52 push %edx <== NOT EXECUTED 10a1e3: 53 push %ebx <== NOT EXECUTED 10a1e4: 53 push %ebx <== NOT EXECUTED 10a1e5: 68 c0 19 12 00 push $0x1219c0 <== NOT EXECUTED 10a1ea: e8 5d 31 00 00 call 10d34c <_Timespec_Subtract> <== NOT EXECUTED 10a1ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1f2: 50 push %eax <== NOT EXECUTED 10a1f3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a1f6: 50 push %eax <== NOT EXECUTED 10a1f7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a1fa: 68 60 1c 12 00 push $0x121c60 <== NOT EXECUTED 10a1ff: e8 dc 1d 00 00 call 10bfe0 <_Objects_Get> <== NOT EXECUTED 10a204: 89 c3 mov %eax,%ebx <== NOT EXECUTED * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a206: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a209: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10a20d: 0f 85 bb 00 00 00 jne 10a2ce <== NOT EXECUTED case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10a213: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) <== NOT EXECUTED 10a217: 75 3b jne 10a254 <== NOT EXECUTED 10a219: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 10a21d: 75 35 jne 10a254 <== NOT EXECUTED /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a21f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a222: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10a225: 50 push %eax <== NOT EXECUTED 10a226: e8 0d 35 00 00 call 10d738 <_Watchdog_Remove> <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 10a22b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a22e: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10a232: 74 0d je 10a241 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10a234: 8d 73 54 lea 0x54(%ebx),%esi <== NOT EXECUTED 10a237: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a23c: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10a23f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = normalize; 10a241: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 10a244: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10a247: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a24c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a24e: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED 10a252: eb 35 jmp 10a289 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a254: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a257: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a25a: e8 25 31 00 00 call 10d384 <_Timespec_To_ticks> <== NOT EXECUTED 10a25f: 89 43 64 mov %eax,0x64(%ebx) <== NOT EXECUTED initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a262: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10a265: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a268: e8 17 31 00 00 call 10d384 <_Timespec_To_ticks> <== NOT EXECUTED activated = _POSIX_Timer_Insert_helper( 10a26d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a270: 68 e4 a2 10 00 push $0x10a2e4 <== NOT EXECUTED 10a275: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a278: 50 push %eax <== NOT EXECUTED 10a279: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a27c: 50 push %eax <== NOT EXECUTED 10a27d: e8 2a 52 00 00 call 10f4ac <_POSIX_Timer_Insert_helper> <== NOT EXECUTED initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a282: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a285: 84 c0 test %al,%al <== NOT EXECUTED 10a287: 75 09 jne 10a292 <== NOT EXECUTED _Thread_Enable_dispatch(); 10a289: e8 12 25 00 00 call 10c7a0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a28e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a290: eb 4a jmp 10a2dc <== NOT EXECUTED /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a292: 83 7d 14 00 cmpl $0x0,0x14(%ebp) <== NOT EXECUTED 10a296: 74 0d je 10a2a5 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10a298: 8d 73 54 lea 0x54(%ebx),%esi <== NOT EXECUTED 10a29b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a2a0: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10a2a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ptimer->timer_data = normalize; 10a2a5: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 10a2a8: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10a2ab: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a2b0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2b2: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED _TOD_Get( &ptimer->time ); 10a2b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2b9: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10a2bc: 50 push %eax <== NOT EXECUTED 10a2bd: e8 8e 15 00 00 call 10b850 <_TOD_Get> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a2c2: e8 d9 24 00 00 call 10c7a0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a2cc: eb 0e jmp 10a2dc <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a2ce: e8 41 69 00 00 call 110c14 <__errno> <== NOT EXECUTED 10a2d3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a2d9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 10a2dc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a2df: 5b pop %ebx <== NOT EXECUTED 10a2e0: 5e pop %esi <== NOT EXECUTED 10a2e1: 5f pop %edi <== NOT EXECUTED 10a2e2: c9 leave <== NOT EXECUTED 10a2e3: c3 ret <== NOT EXECUTED 0010b0a4 : int truncate( const char *path, off_t length ) { 10b0a4: 55 push %ebp <== NOT EXECUTED 10b0a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0a7: 56 push %esi <== NOT EXECUTED 10b0a8: 53 push %ebx <== NOT EXECUTED int status; int fd; fd = open( path, O_WRONLY ); 10b0a9: 52 push %edx <== NOT EXECUTED 10b0aa: 52 push %edx <== NOT EXECUTED 10b0ab: 6a 01 push $0x1 <== NOT EXECUTED 10b0ad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b0b0: e8 c7 df ff ff call 10907c <== NOT EXECUTED 10b0b5: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( fd == -1 ) 10b0b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0ba: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10b0bd: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10b0c0: 74 18 je 10b0da <== NOT EXECUTED return -1; status = ftruncate( fd, length ); 10b0c2: 50 push %eax <== NOT EXECUTED 10b0c3: 50 push %eax <== NOT EXECUTED 10b0c4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b0c7: 53 push %ebx <== NOT EXECUTED 10b0c8: e8 df 46 00 00 call 10f7ac <== NOT EXECUTED 10b0cd: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 10b0cf: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b0d2: e8 9d d0 ff ff call 108174 <== NOT EXECUTED 10b0d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 10b0da: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b0dc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b0df: 5b pop %ebx <== NOT EXECUTED 10b0e0: 5e pop %esi <== NOT EXECUTED 10b0e1: c9 leave <== NOT EXECUTED 10b0e2: c3 ret <== NOT EXECUTED 00120a0c : */ char *ttyname( int fd ) { 120a0c: 55 push %ebp <== NOT EXECUTED 120a0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120a0f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 120a12: 68 06 04 00 00 push $0x406 <== NOT EXECUTED 120a17: 68 a8 4b 14 00 push $0x144ba8 <== NOT EXECUTED 120a1c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120a1f: e8 04 ff ff ff call 120928 <== NOT EXECUTED 120a24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120a27: ba a8 4b 14 00 mov $0x144ba8,%edx <== NOT EXECUTED 120a2c: 85 c0 test %eax,%eax <== NOT EXECUTED 120a2e: 74 02 je 120a32 <== NOT EXECUTED 120a30: 31 d2 xor %edx,%edx <== NOT EXECUTED return ttyname_buf; return NULL; } 120a32: 89 d0 mov %edx,%eax <== NOT EXECUTED 120a34: c9 leave <== NOT EXECUTED 120a35: c3 ret <== NOT EXECUTED 00120928 : int ttyname_r( int fd, char *name, size_t namesize ) { 120928: 55 push %ebp <== NOT EXECUTED 120929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12092b: 57 push %edi <== NOT EXECUTED 12092c: 56 push %esi <== NOT EXECUTED 12092d: 53 push %ebx <== NOT EXECUTED 12092e: 81 ec d4 00 00 00 sub $0xd4,%esp <== NOT EXECUTED 120934: 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) 120937: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 12093a: 50 push %eax <== NOT EXECUTED 12093b: 53 push %ebx <== NOT EXECUTED 12093c: e8 77 ff ff ff call 1208b8 <== NOT EXECUTED 120941: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120944: 85 c0 test %eax,%eax <== NOT EXECUTED 120946: 78 38 js 120980 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) 120948: 56 push %esi <== NOT EXECUTED 120949: 56 push %esi <== NOT EXECUTED 12094a: 8d 45 84 lea -0x7c(%ebp),%eax <== NOT EXECUTED 12094d: 50 push %eax <== NOT EXECUTED 12094e: 53 push %ebx <== NOT EXECUTED 12094f: e8 d8 e6 ff ff call 11f02c <== NOT EXECUTED 120954: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120957: 85 c0 test %eax,%eax <== NOT EXECUTED 120959: 75 25 jne 120980 <== NOT EXECUTED 12095b: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 12095e: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 120963: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 120968: 75 16 jne 120980 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) 12096a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12096d: 68 e3 dd 13 00 push $0x13dde3 <== NOT EXECUTED 120972: e8 bd f9 ff ff call 120334 <== NOT EXECUTED 120977: 89 c3 mov %eax,%ebx <== NOT EXECUTED 120979: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12097c: 85 c0 test %eax,%eax <== NOT EXECUTED 12097e: 75 58 jne 1209d8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); 120980: e8 c7 aa 00 00 call 12b44c <__errno> <== NOT EXECUTED 120985: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12098b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 12098e: eb 74 jmp 120a04 <== NOT EXECUTED for (rval = NULL; (dirp = readdir (dp)) != NULL ;) { if (dirp->d_ino != sb.st_ino) 120990: 8b 02 mov (%edx),%eax <== NOT EXECUTED 120992: 3b 45 8c cmp -0x74(%ebp),%eax <== NOT EXECUTED 120995: 75 4d jne 1209e4 <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 120997: 51 push %ecx <== NOT EXECUTED 120998: 51 push %ecx <== NOT EXECUTED 120999: 8d 42 0c lea 0xc(%edx),%eax <== NOT EXECUTED 12099c: 50 push %eax <== NOT EXECUTED 12099d: 56 push %esi <== NOT EXECUTED 12099e: e8 51 ef 00 00 call 12f8f4 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 1209a3: 58 pop %eax <== NOT EXECUTED 1209a4: 5a pop %edx <== NOT EXECUTED 1209a5: 57 push %edi <== NOT EXECUTED 1209a6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1209a9: e8 de a9 fe ff call 10b38c <== NOT EXECUTED 1209ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1209b1: 85 c0 test %eax,%eax <== NOT EXECUTED 1209b3: 75 2f jne 1209e4 <== NOT EXECUTED 1209b5: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 1209b8: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED 1209bb: 3b 85 3c ff ff ff cmp -0xc4(%ebp),%eax <== NOT EXECUTED 1209c1: 75 21 jne 1209e4 <== NOT EXECUTED 1209c3: 3b 95 38 ff ff ff cmp -0xc8(%ebp),%edx <== NOT EXECUTED 1209c9: 75 19 jne 1209e4 <== NOT EXECUTED 1209cb: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 1209ce: 3b 85 40 ff ff ff cmp -0xc0(%ebp),%eax <== NOT EXECUTED 1209d4: 75 0e jne 1209e4 <== NOT EXECUTED 1209d6: eb 1e jmp 1209f6 <== 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); 1209d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1209db: 83 c6 05 add $0x5,%esi <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 1209de: 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 ;) 1209e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1209e7: 53 push %ebx <== NOT EXECUTED 1209e8: e8 c7 fb ff ff call 1205b4 <== NOT EXECUTED 1209ed: 89 c2 mov %eax,%edx <== NOT EXECUTED 1209ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1209f2: 85 c0 test %eax,%eax <== NOT EXECUTED 1209f4: 75 9a jne 120990 <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 1209f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1209f9: 53 push %ebx <== NOT EXECUTED 1209fa: e8 f9 8d 00 00 call 1297f8 <== NOT EXECUTED 1209ff: 31 c0 xor %eax,%eax <== NOT EXECUTED 120a01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 120a04: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120a07: 5b pop %ebx <== NOT EXECUTED 120a08: 5e pop %esi <== NOT EXECUTED 120a09: 5f pop %edi <== NOT EXECUTED 120a0a: c9 leave <== NOT EXECUTED 120a0b: c3 ret <== NOT EXECUTED 00108d7c : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 108d7c: 55 push %ebp <== NOT EXECUTED 108d7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108d7f: 56 push %esi <== NOT EXECUTED 108d80: 53 push %ebx <== NOT EXECUTED 108d81: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 108d84: 83 3d cc fd 11 00 00 cmpl $0x0,0x11fdcc <== NOT EXECUTED 108d8b: 75 2c jne 108db9 <== 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. * 108d8d: c7 05 b8 fd 11 00 00 movl $0x0,0x11fdb8 <== NOT EXECUTED 108d94: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 108d97: c7 05 cc fd 11 00 5c movl $0x108e5c,0x11fdcc <== NOT EXECUTED 108d9e: 8e 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 108da1: c7 05 d0 fd 11 00 00 movl $0x0,0x11fdd0 <== NOT EXECUTED 108da8: 00 00 00 <== NOT EXECUTED * the heap 108dab: c7 05 d4 fd 11 00 00 movl $0x0,0x11fdd4 <== NOT EXECUTED 108db2: 00 00 00 <== NOT EXECUTED 108db5: 31 f6 xor %esi,%esi <== NOT EXECUTED 108db7: eb 4f jmp 108e08 <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 108db9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108dbc: 68 b0 fd 11 00 push $0x11fdb0 <== NOT EXECUTED 108dc1: e8 16 35 00 00 call 10c2dc <_Watchdog_Remove> <== NOT EXECUTED 108dc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108dc9: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 108dcc: 31 f6 xor %esi,%esi <== NOT EXECUTED 108dce: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108dd1: 77 35 ja 108e08 <== NOT EXECUTED * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 108dd3: a1 c4 fd 11 00 mov 0x11fdc4,%eax <== NOT EXECUTED 108dd8: 03 05 bc fd 11 00 add 0x11fdbc,%eax <== NOT EXECUTED /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 108dde: 51 push %ecx <== NOT EXECUTED 108ddf: 51 push %ecx <== NOT EXECUTED 108de0: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 108de3: 52 push %edx <== NOT EXECUTED 108de4: 2b 05 c8 fd 11 00 sub 0x11fdc8,%eax <== NOT EXECUTED 108dea: 50 push %eax <== NOT EXECUTED 108deb: e8 a4 30 00 00 call 10be94 <_Timespec_From_ticks> <== NOT EXECUTED remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 108df0: 69 4d f0 40 42 0f 00 imul $0xf4240,-0x10(%ebp),%ecx <== NOT EXECUTED remaining += tp.tv_nsec / 1000; 108df7: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 108dfa: bb e8 03 00 00 mov $0x3e8,%ebx <== NOT EXECUTED 108dff: 99 cltd <== NOT EXECUTED 108e00: f7 fb idiv %ebx <== NOT EXECUTED 108e02: 8d 34 08 lea (%eax,%ecx,1),%esi <== NOT EXECUTED 108e05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 108e08: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 108e0c: 74 45 je 108e53 <== NOT EXECUTED Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 108e0e: b9 40 42 0f 00 mov $0xf4240,%ecx <== NOT EXECUTED 108e13: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108e16: 31 d2 xor %edx,%edx <== NOT EXECUTED 108e18: f7 f1 div %ecx <== NOT EXECUTED 108e1a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 108e1d: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx <== NOT EXECUTED 108e23: 89 55 f4 mov %edx,-0xc(%ebp) <== NOT EXECUTED ticks = _Timespec_To_ticks( &tp ); 108e26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e29: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 108e2c: 53 push %ebx <== NOT EXECUTED 108e2d: e8 c6 30 00 00 call 10bef8 <_Timespec_To_ticks> <== NOT EXECUTED if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 108e32: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 108e35: e8 be 30 00 00 call 10bef8 <_Timespec_To_ticks> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 108e3a: a3 bc fd 11 00 mov %eax,0x11fdbc <== NOT EXECUTED void *starting_address, size_t *size 108e3f: 58 pop %eax <== NOT EXECUTED 108e40: 5a pop %edx <== NOT EXECUTED 108e41: 68 b0 fd 11 00 push $0x11fdb0 <== NOT EXECUTED 108e46: 68 70 ff 11 00 push $0x11ff70 <== NOT EXECUTED 108e4b: e8 74 33 00 00 call 10c1c4 <_Watchdog_Insert> <== NOT EXECUTED 108e50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return remaining; } 108e53: 89 f0 mov %esi,%eax <== NOT EXECUTED 108e55: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108e58: 5b pop %ebx <== NOT EXECUTED 108e59: 5e pop %esi <== NOT EXECUTED 108e5a: c9 leave <== NOT EXECUTED 108e5b: c3 ret <== NOT EXECUTED 00120a38 : #include mode_t umask( mode_t cmask ) { 120a38: 55 push %ebp <== NOT EXECUTED 120a39: 89 e5 mov %esp,%ebp <== NOT EXECUTED mode_t old_mask; old_mask = rtems_filesystem_umask; 120a3b: 8b 15 a4 4b 14 00 mov 0x144ba4,%edx <== NOT EXECUTED 120a41: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED rtems_filesystem_umask = cmask; 120a44: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 120a47: 89 4a 24 mov %ecx,0x24(%edx) <== NOT EXECUTED return old_mask; } 120a4a: c9 leave <== NOT EXECUTED 120a4b: c3 ret <== NOT EXECUTED 0010975c : */ int uname( struct utsname *name ) { 10975c: 55 push %ebp <== NOT EXECUTED 10975d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10975f: 53 push %ebx <== NOT EXECUTED 109760: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109763: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED release = 5.3 version = Generic_101318-12 machine = sun4m */ if ( !name ) 109766: 85 db test %ebx,%ebx <== NOT EXECUTED 109768: 75 10 jne 10977a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 10976a: e8 21 70 00 00 call 110790 <__errno> <== NOT EXECUTED 10976f: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 109775: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109778: eb 60 jmp 1097da <== NOT EXECUTED strcpy( name->sysname, "RTEMS" ); 10977a: 50 push %eax <== NOT EXECUTED 10977b: 50 push %eax <== NOT EXECUTED 10977c: 68 c5 95 11 00 push $0x1195c5 <== NOT EXECUTED 109781: 53 push %ebx <== NOT EXECUTED 109782: e8 c1 86 00 00 call 111e48 <== NOT EXECUTED sprintf( name->nodename, "Node %" PRId16, _Objects_Local_node ); 109787: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10978a: 6a 01 push $0x1 <== NOT EXECUTED 10978c: 68 5f a8 11 00 push $0x11a85f <== NOT EXECUTED 109791: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 109794: 50 push %eax <== NOT EXECUTED 109795: e8 d2 84 00 00 call 111c6c <== NOT EXECUTED strcpy( name->release, RTEMS_VERSION ); 10979a: 59 pop %ecx <== NOT EXECUTED 10979b: 58 pop %eax <== NOT EXECUTED 10979c: 68 67 a8 11 00 push $0x11a867 <== NOT EXECUTED 1097a1: 8d 43 40 lea 0x40(%ebx),%eax <== NOT EXECUTED 1097a4: 50 push %eax <== NOT EXECUTED 1097a5: e8 9e 86 00 00 call 111e48 <== NOT EXECUTED strcpy( name->version, "" ); 1097aa: 58 pop %eax <== NOT EXECUTED 1097ab: 5a pop %edx <== NOT EXECUTED 1097ac: 68 5e a8 11 00 push $0x11a85e <== NOT EXECUTED 1097b1: 8d 43 60 lea 0x60(%ebx),%eax <== NOT EXECUTED 1097b4: 50 push %eax <== NOT EXECUTED 1097b5: e8 8e 86 00 00 call 111e48 <== NOT EXECUTED sprintf( name->machine, "%s/%s", CPU_NAME, CPU_MODEL_NAME ); 1097ba: 68 6d a8 11 00 push $0x11a86d <== NOT EXECUTED 1097bf: 68 7c a8 11 00 push $0x11a87c <== NOT EXECUTED 1097c4: 68 87 a8 11 00 push $0x11a887 <== NOT EXECUTED 1097c9: 8d 83 80 00 00 00 lea 0x80(%ebx),%eax <== NOT EXECUTED 1097cf: 50 push %eax <== NOT EXECUTED 1097d0: e8 97 84 00 00 call 111c6c <== NOT EXECUTED 1097d5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097d7: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return 0; } 1097da: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1097dd: c9 leave <== NOT EXECUTED 1097de: 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 c7 e6 01 00 call 12b44c <__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 54 e6 01 00 call 12b44c <__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 30 e6 01 00 call 12b44c <__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 00120a86 : */ int unmount( const char *path ) { 120a86: 55 push %ebp <== NOT EXECUTED 120a87: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120a89: 56 push %esi <== NOT EXECUTED 120a8a: 53 push %ebx <== NOT EXECUTED 120a8b: 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 ) ) 120a8e: 6a 01 push $0x1 <== NOT EXECUTED 120a90: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 120a93: 56 push %esi <== NOT EXECUTED 120a94: 6a 00 push $0x0 <== NOT EXECUTED 120a96: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120a99: e8 5c 94 fe ff call 109efa <== NOT EXECUTED 120a9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120aa1: 85 c0 test %eax,%eax <== NOT EXECUTED 120aa3: 0f 85 11 01 00 00 jne 120bba <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 120aa9: 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) ){ 120aac: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 120aaf: 3b 45 e8 cmp -0x18(%ebp),%eax <== NOT EXECUTED 120ab2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 120ab5: 74 24 je 120adb <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 120ab7: 85 c0 test %eax,%eax <== NOT EXECUTED 120ab9: 74 10 je 120acb <== NOT EXECUTED 120abb: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120abe: 85 c0 test %eax,%eax <== NOT EXECUTED 120ac0: 74 09 je 120acb <== NOT EXECUTED 120ac2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ac5: 56 push %esi <== NOT EXECUTED 120ac6: ff d0 call *%eax <== NOT EXECUTED 120ac8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 120acb: e8 7c a9 00 00 call 12b44c <__errno> <== NOT EXECUTED 120ad0: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 120ad6: e9 df 00 00 00 jmp 120bba <== NOT EXECUTED /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 120adb: 85 c0 test %eax,%eax <== NOT EXECUTED 120add: 74 10 je 120aef <== NOT EXECUTED 120adf: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120ae2: 85 c0 test %eax,%eax <== NOT EXECUTED 120ae4: 74 09 je 120aef <== NOT EXECUTED 120ae6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ae9: 56 push %esi <== NOT EXECUTED 120aea: ff d0 call *%eax <== NOT EXECUTED 120aec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 120aef: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120af2: 83 78 28 00 cmpl $0x0,0x28(%eax) <== NOT EXECUTED 120af6: 74 09 je 120b01 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 120af8: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 120afb: 83 78 2c 00 cmpl $0x0,0x2c(%eax) <== NOT EXECUTED 120aff: 75 10 jne 120b11 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 120b01: e8 46 a9 00 00 call 12b44c <__errno> <== NOT EXECUTED 120b06: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120b0c: e9 a9 00 00 00 jmp 120bba <== 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 ) 120b11: a1 a4 4b 14 00 mov 0x144ba4,%eax <== NOT EXECUTED 120b16: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 120b19: 74 1f je 120b3a <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 120b1b: 8b 15 fc ab 15 00 mov 0x15abfc,%edx <== NOT EXECUTED 120b21: eb 0a jmp 120b2d <== 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 ) { 120b23: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 120b26: 3b 43 24 cmp 0x24(%ebx),%eax <== NOT EXECUTED 120b29: 74 0f je 120b3a <== 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 ) { 120b2b: 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 ); 120b2d: 81 fa 00 ac 15 00 cmp $0x15ac00,%edx <== NOT EXECUTED 120b33: 75 ee jne 120b23 <== NOT EXECUTED 120b35: e9 8a 00 00 00 jmp 120bc4 <== 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 ); 120b3a: e8 0d a9 00 00 call 12b44c <__errno> <== NOT EXECUTED 120b3f: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 120b45: eb 73 jmp 120bba <== 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 ) 120b47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b4a: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120b4d: 53 push %ebx <== NOT EXECUTED 120b4e: ff 50 28 call *0x28(%eax) <== NOT EXECUTED 120b51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b54: 85 c0 test %eax,%eax <== NOT EXECUTED 120b56: 75 62 jne 120bba <== 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){ 120b58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b5b: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 120b5e: 53 push %ebx <== NOT EXECUTED 120b5f: ff 50 2c call *0x2c(%eax) <== NOT EXECUTED 120b62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b65: 85 c0 test %eax,%eax <== NOT EXECUTED 120b67: 74 1b je 120b84 <== NOT EXECUTED if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 120b69: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b6c: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120b6f: 53 push %ebx <== NOT EXECUTED 120b70: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 120b73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b76: 85 c0 test %eax,%eax <== NOT EXECUTED 120b78: 74 40 je 120bba <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 120b7a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b7d: 6a 00 push $0x0 <== NOT EXECUTED 120b7f: e8 f8 d2 fe ff call 10de7c <== NOT EXECUTED 120b84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b87: 53 push %ebx <== NOT EXECUTED 120b88: e8 6b d6 fe ff call 10e1f8 <_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 ); 120b8d: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 120b90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120b93: 85 c0 test %eax,%eax <== NOT EXECUTED 120b95: 74 13 je 120baa <== NOT EXECUTED 120b97: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 120b9a: 85 d2 test %edx,%edx <== NOT EXECUTED 120b9c: 74 0c je 120baa <== NOT EXECUTED 120b9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120ba1: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 120ba4: 50 push %eax <== NOT EXECUTED 120ba5: ff d2 call *%edx <== NOT EXECUTED 120ba7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( mt_entry ); 120baa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120bad: 53 push %ebx <== NOT EXECUTED 120bae: e8 69 94 fe ff call 10a01c <== NOT EXECUTED 120bb3: 31 c0 xor %eax,%eax <== NOT EXECUTED 120bb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120bb8: eb 03 jmp 120bbd <== NOT EXECUTED return 0; 120bba: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 120bbd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120bc0: 5b pop %ebx <== NOT EXECUTED 120bc1: 5e pop %esi <== NOT EXECUTED 120bc2: c9 leave <== NOT EXECUTED 120bc3: 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 ) 120bc4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120bc7: 53 push %ebx <== NOT EXECUTED 120bc8: e8 7f 96 fe ff call 10a24c <== NOT EXECUTED 120bcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120bd0: 48 dec %eax <== NOT EXECUTED 120bd1: 0f 85 70 ff ff ff jne 120b47 <== NOT EXECUTED 120bd7: e9 5e ff ff ff jmp 120b3a <== NOT EXECUTED 0010bcbc : int usleep( useconds_t useconds ) { 10bcbc: 55 push %ebp <== NOT EXECUTED 10bcbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcbf: 53 push %ebx <== NOT EXECUTED 10bcc0: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10bcc3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10bcc6: ba 40 42 0f 00 mov $0xf4240,%edx <== NOT EXECUTED 10bccb: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10bccd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bccf: f7 f1 div %ecx <== NOT EXECUTED 10bcd1: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10bcd4: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx <== NOT EXECUTED 10bcda: 89 55 f8 mov %edx,-0x8(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 10bcdd: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10bce0: 50 push %eax <== NOT EXECUTED 10bce1: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bce4: 50 push %eax <== NOT EXECUTED 10bce5: e8 4e 67 00 00 call 112438 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10bcea: 69 4d ec 40 42 0f 00 imul $0xf4240,-0x14(%ebp),%ecx <== NOT EXECUTED 10bcf1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10bcf4: bb e8 03 00 00 mov $0x3e8,%ebx <== NOT EXECUTED 10bcf9: 99 cltd <== NOT EXECUTED 10bcfa: f7 fb idiv %ebx <== NOT EXECUTED 10bcfc: 01 c8 add %ecx,%eax <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 10bcfe: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd01: c9 leave <== NOT EXECUTED 10bd02: c3 ret <== NOT EXECUTED 00120bdc : int utime( const char *path, const struct utimbuf *times ) { 120bdc: 55 push %ebp <== NOT EXECUTED 120bdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120bdf: 57 push %edi <== NOT EXECUTED 120be0: 56 push %esi <== NOT EXECUTED 120be1: 53 push %ebx <== NOT EXECUTED 120be2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 120be5: 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 ) ) 120be8: 6a 01 push $0x1 <== NOT EXECUTED 120bea: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 120bed: 56 push %esi <== NOT EXECUTED 120bee: 6a 00 push $0x0 <== NOT EXECUTED 120bf0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120bf3: e8 02 93 fe ff call 109efa <== NOT EXECUTED 120bf8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120bfb: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 120bfe: 85 c0 test %eax,%eax <== NOT EXECUTED 120c00: 75 4f jne 120c51 <== NOT EXECUTED return -1; if ( !temp_loc.ops->utime_h ){ 120c02: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120c05: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 120c08: 85 d2 test %edx,%edx <== NOT EXECUTED 120c0a: 75 20 jne 120c2c <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 120c0c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120c0f: 85 c0 test %eax,%eax <== NOT EXECUTED 120c11: 74 09 je 120c1c <== NOT EXECUTED 120c13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120c16: 56 push %esi <== NOT EXECUTED 120c17: ff d0 call *%eax <== NOT EXECUTED 120c19: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 120c1c: e8 2b a8 00 00 call 12b44c <__errno> <== NOT EXECUTED 120c21: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 120c27: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 120c2a: eb 25 jmp 120c51 <== NOT EXECUTED } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 120c2c: 50 push %eax <== NOT EXECUTED 120c2d: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 120c30: ff 37 pushl (%edi) <== NOT EXECUTED 120c32: 56 push %esi <== NOT EXECUTED 120c33: ff d2 call *%edx <== NOT EXECUTED 120c35: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 120c37: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 120c3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120c3d: 85 c0 test %eax,%eax <== NOT EXECUTED 120c3f: 74 10 je 120c51 <== NOT EXECUTED 120c41: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 120c44: 85 c0 test %eax,%eax <== NOT EXECUTED 120c46: 74 09 je 120c51 <== NOT EXECUTED 120c48: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120c4b: 56 push %esi <== NOT EXECUTED 120c4c: ff d0 call *%eax <== NOT EXECUTED 120c4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 120c51: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120c53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120c56: 5b pop %ebx <== NOT EXECUTED 120c57: 5e pop %esi <== NOT EXECUTED 120c58: 5f pop %edi <== NOT EXECUTED 120c59: c9 leave <== NOT EXECUTED 120c5a: 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 dc 92 11 00 call *0x1192dc <== 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 dc 92 11 00 call *0x1192dc <== 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 dc 92 11 00 call *0x1192dc <== 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 dc 92 11 00 call *0x1192dc <== 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 71 11 00 movsbl 0x117182(%eax),%eax <== NOT EXECUTED 106ff3: 50 push %eax <== NOT EXECUTED 106ff4: ff 15 dc 92 11 00 call *0x1192dc <== 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 dc 92 11 00 call *0x1192dc <== 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 0010930c : #include int wait( int *stat_loc ) { 10930c: 55 push %ebp <== NOT EXECUTED 10930d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10930f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 109312: e8 bd 6a 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 109317: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10931d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109320: c9 leave <== NOT EXECUTED 109321: c3 ret <== NOT EXECUTED 00109324 : int waitpid( pid_t pid, int *stat_loc, int options ) { 109324: 55 push %ebp <== NOT EXECUTED 109325: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109327: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10932a: e8 a5 6a 00 00 call 10fdd4 <__errno> <== NOT EXECUTED 10932f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 109335: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109338: c9 leave <== NOT EXECUTED 109339: c3 ret <== NOT EXECUTED 001158e0 : ssize_t write( int fd, const void *buffer, size_t count ) { 1158e0: 55 push %ebp <== NOT EXECUTED 1158e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1158e3: 56 push %esi <== NOT EXECUTED 1158e4: 53 push %ebx <== NOT EXECUTED 1158e5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1158e8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1158eb: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1158ee: 3b 05 b8 91 11 00 cmp 0x1191b8,%eax <== NOT EXECUTED 1158f4: 73 11 jae 115907 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1158f6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED 1158f9: 03 1d 18 d5 11 00 add 0x11d518,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 1158ff: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 115902: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 115905: 75 0d jne 115914 <== NOT EXECUTED 115907: e8 ac 97 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 11590c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 115912: eb 31 jmp 115945 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 115914: 85 f6 test %esi,%esi <== NOT EXECUTED 115916: 74 0b je 115923 <== NOT EXECUTED rtems_libio_check_count( count ); 115918: 31 c0 xor %eax,%eax <== NOT EXECUTED 11591a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11591c: 74 3c je 11595a <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11591e: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 115921: 75 0d jne 115930 <== NOT EXECUTED 115923: e8 90 97 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 115928: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11592e: eb 15 jmp 115945 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 115930: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 115933: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 115936: 85 c0 test %eax,%eax <== NOT EXECUTED 115938: 75 10 jne 11594a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 11593a: e8 79 97 ff ff call 10f0b8 <__errno> <== NOT EXECUTED 11593f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 115945: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 115948: eb 10 jmp 11595a <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 11594a: 52 push %edx <== NOT EXECUTED 11594b: 51 push %ecx <== NOT EXECUTED 11594c: 56 push %esi <== NOT EXECUTED 11594d: 53 push %ebx <== NOT EXECUTED 11594e: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 115950: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115953: 85 c0 test %eax,%eax <== NOT EXECUTED 115955: 7e 03 jle 11595a <== NOT EXECUTED iop->offset += rc; 115957: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 11595a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11595d: 5b pop %ebx <== NOT EXECUTED 11595e: 5e pop %esi <== NOT EXECUTED 11595f: c9 leave <== NOT EXECUTED 115960: c3 ret <== NOT EXECUTED