000465d8 <_API_Mutex_Allocate>:
#include <rtems/score/apimutex.h>

void _API_Mutex_Allocate(
  API_Mutex_Control **the_mutex
)
{
   465d8:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
  CORE_mutex_Attributes attr =  {
    CORE_MUTEX_NESTING_IS_ERROR,
    FALSE,
    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    0
  };
   465dc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   465de:	2d40 fff2      	movel %d0,%fp@(-14)                               	<== NOT EXECUTED
   465e2:	4200           	clrb %d0                                          	<== NOT EXECUTED
   465e4:	1d40 fff6      	moveb %d0,%fp@(-10)                               	<== NOT EXECUTED
#include <rtems/score/apimutex.h>

void _API_Mutex_Allocate(
  API_Mutex_Control **the_mutex
)
{
   465e8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  CORE_mutex_Attributes attr =  {
    CORE_MUTEX_NESTING_IS_ERROR,
    FALSE,
    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    0
  };
   465ea:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED

  mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information );
   465ec:	4879 0005 883c 	pea 5883c <_API_Mutex_Information>                	<== NOT EXECUTED
  CORE_mutex_Attributes attr =  {
    CORE_MUTEX_NESTING_IS_ERROR,
    FALSE,
    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    0
  };
   465f2:	2d40 fff8      	movel %d0,%fp@(-8)                                	<== NOT EXECUTED
   465f6:	42ae fffc      	clrl %fp@(-4)                                     	<== NOT EXECUTED

  mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information );
   465fa:	4eb9 0004 6f0c 	jsr 46f0c <_Objects_Allocate>                     	<== NOT EXECUTED

  _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED );
   46600:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
    FALSE,
    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    0
  };

  mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information );
   46604:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED );
   46606:	486e fff2      	pea %fp@(-14)                                     	<== NOT EXECUTED
   4660a:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4660e:	4eb9 0004 671c 	jsr 4671c <_CORE_mutex_Initialize>                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   46614:	2079 0005 8856 	moveal 58856 <_API_Mutex_Information+0x1a>,%a0    	<== NOT EXECUTED
   4661a:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4661c:	322a 000a      	movew %a2@(10),%d1                                	<== NOT EXECUTED
   46620:	218a 1c00      	movel %a2,%a0@(00000000,%d1:l:4)                  	<== NOT EXECUTED
    _Objects_Get_index( the_object->id ),
    the_object
  );

  /* ASSERT: information->is_string == FALSE */
  the_object->name.name_u32 = name;
   46624:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

  _Objects_Open_u32( &_API_Mutex_Information, &mutex->Object, 1 );

  *the_mutex = mutex;
   46626:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4662c:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
   46630:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   46634:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
}
   46636:	246e ffec      	moveal %fp@(-20),%a2                              	<== NOT EXECUTED
   4663a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4663c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046674 <_API_Mutex_Initialization>:
#include <rtems/score/apimutex.h>

void _API_Mutex_Initialization(
  uint32_t maximum_mutexes
)
{
   46674:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   46678:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4667a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4667c:	4878 0072      	pea 72 <FP_REGS_SAVED+0x32>                       	<== NOT EXECUTED
   46680:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46684:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   46688:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4668c:	4879 0005 883c 	pea 5883c <_API_Mutex_Information>                	<== NOT EXECUTED
   46692:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   46698:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    TRUE,                        /* TRUE if this is a global object class */
    NULL                         /* Proxy extraction support callout */
#endif
  );
}
   4669e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   466a0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046640 <_API_Mutex_Lock>:
#include <rtems/score/apimutex.h>

void _API_Mutex_Lock(
  API_Mutex_Control *the_mutex
)
{
   46640:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   46644:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
#include <rtems/score/apimutex.h>

void _API_Mutex_Lock(
  API_Mutex_Control *the_mutex
)
{
   4664a:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4664e:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   46650:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   46652:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _CORE_mutex_Seize(
   46654:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46656:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46658:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4665c:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   46660:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   46664:	4eb9 0004 68a6 	jsr 468a6 <_CORE_mutex_Seize>                     	<== NOT EXECUTED
   4666a:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    the_mutex->Object.id,
    TRUE,
    0,
    level
  );
}
   46670:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46672:	4e75           	rts

000466a4 <_API_Mutex_Unlock>:
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   466a4:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
#include <rtems/score/apimutex.h>

void _API_Mutex_Unlock(
  API_Mutex_Control *the_mutex
)
{
   466aa:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   466ae:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   466b0:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   466b6:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  _Thread_Disable_dispatch();
    _CORE_mutex_Surrender(
   466ba:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   466bc:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   466c0:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   466c4:	4eb9 0004 6958 	jsr 46958 <_CORE_mutex_Surrender>                 	<== NOT EXECUTED
      &the_mutex->Mutex,
      the_mutex->Object.id,
      NULL
   );
  _Thread_Enable_dispatch();
   466ca:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   466d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _CORE_mutex_Surrender(
      &the_mutex->Mutex,
      the_mutex->Object.id,
      NULL
   );
  _Thread_Enable_dispatch();
   466d2:	4ef9 0004 7cbc 	jmp 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED

000465bc <_API_extensions_Add>:
 */

void _API_extensions_Add(
  API_extensions_Control *the_extension
)
{
   465bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Chain_Append( &_API_extensions_List, &the_extension->Node );
   465c0:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   465c4:	4879 0005 88fe 	pea 588fe <_API_extensions_List>                  	<== NOT EXECUTED
   465ca:	4eb9 0004 66d8 	jsr 466d8 <_Chain_Append>                         	<== NOT EXECUTED
   465d0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   465d2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465d4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046504 <_API_extensions_Initialization>:
 *
 *  _API_extensions_Initialization
 */

void _API_extensions_Initialization( void )
{
   46504:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   46508:	41f9 0005 88fe 	lea 588fe <_API_extensions_List>,%a0              	<== NOT EXECUTED
 _Chain_Initialize_empty( &_API_extensions_List );
}
   4650e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   46510:	23c8 0005 8906 	movel %a0,58906 <_API_extensions_List+0x8>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   46516:	20bc 0005 8902 	movel #362754,%a0@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4651c:	42b9 0005 8902 	clrl 58902 <_API_extensions_List+0x4>             	<== NOT EXECUTED
   46522:	4e75           	rts

00046554 <_API_extensions_Run_postdriver>:
 *
 *  _API_extensions_Run_postdriver
 */

void _API_extensions_Run_postdriver( void )
{
   46554:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46558:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node             *the_node;
  API_extensions_Control *the_extension;

  for ( the_node = _API_extensions_List.first ;
   4655a:	2479 0005 88fe 	moveal 588fe <_API_extensions_List>,%a2           	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
   46560:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   46566:	6714           	beqs 4657c <_API_extensions_Run_postdriver+0x28>  	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postdriver_hook )
   46568:	206a 000c      	moveal %a2@(12),%a0                               	<== NOT EXECUTED
   4656c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4656e:	6702           	beqs 46572 <_API_extensions_Run_postdriver+0x1e>  	<== NOT EXECUTED
      (*the_extension->postdriver_hook)();
   46570:	4e90           	jsr %a0@                                          	<== 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 ) {
   46572:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   46574:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   4657a:	66ec           	bnes 46568 <_API_extensions_Run_postdriver+0x14>  	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postdriver_hook )
      (*the_extension->postdriver_hook)();
  }
}
   4657c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46580:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46582:	4e75           	rts

00046584 <_API_extensions_Run_postswitch>:
 *
 *  _API_extensions_Run_postswitch
 */

void _API_extensions_Run_postswitch( void )
{
   46584:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46588:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node             *the_node;
  API_extensions_Control *the_extension;

  for ( the_node = _API_extensions_List.first ;
   4658a:	2479 0005 88fe 	moveal 588fe <_API_extensions_List>,%a2           	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
   46590:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   46596:	671c           	beqs 465b4 <_API_extensions_Run_postswitch+0x30>  	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postswitch_hook )
   46598:	206a 0010      	moveal %a2@(16),%a0                               	<== NOT EXECUTED
   4659c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4659e:	670a           	beqs 465aa <_API_extensions_Run_postswitch+0x26>  	<== NOT EXECUTED
      (*the_extension->postswitch_hook)( _Thread_Executing );
   465a0:	2f39 0005 8812 	movel 58812 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   465a6:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   465a8:	588f           	addql #4,%sp                                      	<== 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 ) {
   465aa:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   465ac:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   465b2:	66e4           	bnes 46598 <_API_extensions_Run_postswitch+0x14>  	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postswitch_hook )
      (*the_extension->postswitch_hook)( _Thread_Executing );
  }
}
   465b4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   465b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465ba:	4e75           	rts

00046524 <_API_extensions_Run_predriver>:
 *
 *  _API_extensions_Run_predriver
 */

void _API_extensions_Run_predriver( void )
{
   46524:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46528:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node             *the_node;
  API_extensions_Control *the_extension;

  for ( the_node = _API_extensions_List.first ;
   4652a:	2479 0005 88fe 	moveal 588fe <_API_extensions_List>,%a2           	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
   46530:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   46536:	6714           	beqs 4654c <_API_extensions_Run_predriver+0x28>   	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->predriver_hook )
   46538:	206a 0008      	moveal %a2@(8),%a0                                	<== NOT EXECUTED
   4653c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4653e:	6702           	beqs 46542 <_API_extensions_Run_predriver+0x1e>   	<== NOT EXECUTED
      (*the_extension->predriver_hook)();
   46540:	4e90           	jsr %a0@                                          	<== 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 ) {
   46542:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   46544:	b5fc 0005 8902 	cmpal #362754,%a2                                 	<== NOT EXECUTED
   4654a:	66ec           	bnes 46538 <_API_extensions_Run_predriver+0x14>   	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->predriver_hook )
      (*the_extension->predriver_hook)();
  }
}
   4654c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46550:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46552:	4e75           	rts

0004ad1c <_Barrier_Manager_initialization>:
 */

void _Barrier_Manager_initialization(
  uint32_t   maximum_barriers
)
{
   4ad1c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ad20:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ad24:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ad26:	4878 0060      	pea 60 <FP_REGS_SAVED+0x20>                       	<== NOT EXECUTED
   4ad2a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ad2e:	4878 000a      	pea a <LASTO>                                     	<== NOT EXECUTED
   4ad32:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ad36:	4879 0005 89d6 	pea 589d6 <_Barrier_Information>                  	<== NOT EXECUTED
   4ad3c:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4ad42:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                         /* TRUE if this is a global object class */
    NULL                           /* Proxy extraction support callout */
#endif
  );
}
   4ad48:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ad4a:	4e75           	rts

0004bdc0 <_Barrier_Translate_core_barrier_return_code>:
};

rtems_status_code _Barrier_Translate_core_barrier_return_code (
  CORE_barrier_Status  the_barrier_status
)
{
   4bdc0:	4e56 0000      	linkw %fp,#0                                      	<== 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];
}
   4bdc4:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
};

rtems_status_code _Barrier_Translate_core_barrier_return_code (
  CORE_barrier_Status  the_barrier_status
)
{
   4bdc8:	41f9 0005 9488 	lea 59488 <_Barrier_Translate_core_barrier_return_code_>,%a0	<== 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];
}
   4bdce:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   4bdd2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bdd4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047678 <_CORE_barrier_Initialize>:

void _CORE_barrier_Initialize(
  CORE_barrier_Control       *the_barrier,
  CORE_barrier_Attributes    *the_barrier_attributes
)
{
   47678:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED

  the_barrier->Attributes                = *the_barrier_attributes;
  the_barrier->number_of_waiting_threads = 0;

  _Thread_queue_Initialize(
   4767c:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED

void _CORE_barrier_Initialize(
  CORE_barrier_Control       *the_barrier,
  CORE_barrier_Attributes    *the_barrier_attributes
)
{
   47680:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   47684:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED

  the_barrier->Attributes                = *the_barrier_attributes;
  the_barrier->number_of_waiting_threads = 0;

  _Thread_queue_Initialize(
   47688:	2f3c 0001 0000 	movel #65536,%sp@-                                	<== NOT EXECUTED
  CORE_barrier_Control       *the_barrier,
  CORE_barrier_Attributes    *the_barrier_attributes
)
{

  the_barrier->Attributes                = *the_barrier_attributes;
   4768e:	2011           	movel %a1@,%d0                                    	<== NOT EXECUTED
   47690:	2169 0004 0044 	movel %a1@(4),%a0@(68)                            	<== NOT EXECUTED
  the_barrier->number_of_waiting_threads = 0;

  _Thread_queue_Initialize(
   47696:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
  CORE_barrier_Control       *the_barrier,
  CORE_barrier_Attributes    *the_barrier_attributes
)
{

  the_barrier->Attributes                = *the_barrier_attributes;
   47698:	2140 0040      	movel %d0,%a0@(64)                                	<== NOT EXECUTED
  the_barrier->number_of_waiting_threads = 0;

  _Thread_queue_Initialize(
   4769c:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
  CORE_barrier_Attributes    *the_barrier_attributes
)
{

  the_barrier->Attributes                = *the_barrier_attributes;
  the_barrier->number_of_waiting_threads = 0;
   4769e:	42a8 0048      	clrl %a0@(72)                                     	<== NOT EXECUTED

  _Thread_queue_Initialize(
   476a2:	4eb9 0004 9550 	jsr 49550 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   476a8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    &the_barrier->Wait_queue,
    THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_BARRIER,
    CORE_BARRIER_TIMEOUT
  );
}
   476ae:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   476b0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000476b4 <_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
)
{
   476b4:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   476b8:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   476bc:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   476c0:	45f9 0004 912c 	lea 4912c <_Thread_queue_Dequeue>,%a2             	<== NOT EXECUTED
  Thread_Control *the_thread;
  uint32_t        count;

  count = 0;
  while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
   476c6:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   476c8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   476ca:	4282           	clrl %d2                                          	<== NOT EXECUTED
   476cc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   476ce:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   476d0:	670c           	beqs 476de <_CORE_barrier_Release+0x2a>           	<== NOT EXECUTED
   476d2:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   476d4:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_barrier_mp_support) ( the_thread, id );
#endif
    count++;
   476d6:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
{
  Thread_Control *the_thread;
  uint32_t        count;

  count = 0;
  while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
   476d8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   476da:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   476dc:	66f4           	bnes 476d2 <_CORE_barrier_Release+0x1e>           	<== NOT EXECUTED
#endif
    count++;
  }
  the_barrier->number_of_waiting_threads = 0;
  return count;
}
   476de:	2002           	movel %d2,%d0                                     	<== 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;
   476e0:	42ab 0048      	clrl %a3@(72)                                     	<== NOT EXECUTED
  return count;
}
   476e4:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   476ea:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   476ec:	4e75           	rts                                               	<== NOT EXECUTED
	...

000476f0 <_CORE_barrier_Wait>:
  Objects_Id                           id,
  bool                                 wait,
  Watchdog_Interval                    timeout,
  CORE_barrier_API_mp_support_callout  api_barrier_mp_support
)
{
   476f0:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   476f4:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   476f8:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   476fc:	262e 0014      	movel %fp@(20),%d3                                	<== NOT EXECUTED
  Thread_Control *executing;
  ISR_Level       level;

  executing = _Thread_Executing;
   47700:	2279 0005 ac3a 	moveal 5ac3a <_Thread_Executing>,%a1              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   47706:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
{
  Thread_Control *executing;
  ISR_Level       level;

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
   4770c:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED
  Objects_Id                           id,
  bool                                 wait,
  Watchdog_Interval                    timeout,
  CORE_barrier_API_mp_support_callout  api_barrier_mp_support
)
{
   47710:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   47714:	282e 0018      	movel %fp@(24),%d4                                	<== NOT EXECUTED
  Thread_Control *executing;
  ISR_Level       level;

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   47718:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4771a:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4771c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  the_barrier->number_of_waiting_threads++;
   4771e:	2028 0048      	movel %a0@(72),%d0                                	<== NOT EXECUTED
   47722:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47724:	2140 0048      	movel %d0,%a0@(72)                                	<== NOT EXECUTED
  if ( the_barrier->number_of_waiting_threads ==
   47728:	b0a8 0044      	cmpl %a0@(68),%d0                                 	<== NOT EXECUTED
   4772c:	6606           	bnes 47734 <_CORE_barrier_Wait+0x44>              	<== NOT EXECUTED
       the_barrier->Attributes.maximum_count) {
    if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
   4772e:	4aa8 0040      	tstl %a0@(64)                                     	<== NOT EXECUTED
   47732:	672e           	beqs 47762 <_CORE_barrier_Wait+0x72>              	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   47734:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    }
  }

  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
  executing->Wait.queue          = &the_barrier->Wait_queue;
  executing->Wait.id             = id;
   47736:	2342 0020      	movel %d2,%a1@(32)                                	<== NOT EXECUTED
   4773a:	2140 0030      	movel %d0,%a0@(48)                                	<== NOT EXECUTED
      return;
    }
  }

  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
  executing->Wait.queue          = &the_barrier->Wait_queue;
   4773e:	2348 0044      	movel %a0,%a1@(68)                                	<== NOT EXECUTED
  executing->Wait.id             = id;
  _ISR_Enable( level );
   47742:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
   47744:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   47748:	203c 0004 9654 	movel #300628,%d0                                 	<== NOT EXECUTED
   4774e:	2d40 0010      	movel %d0,%fp@(16)                                	<== NOT EXECUTED
   47752:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
}
   47756:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   4775a:	4e5e           	unlk %fp                                          	<== 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 );
   4775c:	4ef9 0004 9294 	jmp 49294 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
  _ISR_Disable( level );
  the_barrier->number_of_waiting_threads++;
  if ( the_barrier->number_of_waiting_threads ==
       the_barrier->Attributes.maximum_count) {
    if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
   47762:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47764:	2340 0034      	movel %d0,%a1@(52)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   47768:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
   4776a:	2d44 0010      	movel %d4,%fp@(16)                                	<== NOT EXECUTED
   4776e:	2d42 000c      	movel %d2,%fp@(12)                                	<== NOT EXECUTED
   47772:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
  executing->Wait.queue          = &the_barrier->Wait_queue;
  executing->Wait.id             = id;
  _ISR_Enable( level );

  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
   47776:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   4777a:	4e5e           	unlk %fp                                          	<== 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 );
   4777c:	4ef9 0004 76b4 	jmp 476b4 <_CORE_barrier_Release>                 	<== NOT EXECUTED
	...

00054108 <_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
)
{
   54108:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   5410c:	48d7 3c1c      	moveml %d2-%d4/%a2-%a5,%sp@                       	<== NOT EXECUTED
   54110:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   54114:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   54118:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
   5411c:	b6ab 004c      	cmpl %a3@(76),%d3                                 	<== NOT EXECUTED
   54120:	6268           	bhis 5418a <_CORE_message_queue_Broadcast+0x82>   	<== 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 ) {
   54122:	4aab 0048      	tstl %a3@(72)                                     	<== NOT EXECUTED
   54126:	6650           	bnes 54178 <_CORE_message_queue_Broadcast+0x70>   	<== 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))) {
   54128:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5412a:	49f9 0005 66a0 	lea 566a0 <_Thread_queue_Dequeue>,%a4             	<== NOT EXECUTED
   54130:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   54132:	4282           	clrl %d2                                          	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   54134:	4bf9 0005 b4b0 	lea 5b4b0 <memcpy>,%a5                            	<== NOT EXECUTED
   5413a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   5413c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   5413e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   54140:	6724           	beqs 54166 <_CORE_message_queue_Broadcast+0x5e>   	<== NOT EXECUTED
   54142:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
    waitp = &the_thread->Wait;
    number_broadcasted += 1;
   54144:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   54146:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   54148:	2f2a 002c      	movel %a2@(44),%sp@-                              	<== NOT EXECUTED
   5414c:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
      buffer,
      waitp->return_argument_second.mutable_object,
      size
    );

    *(size_t *) the_thread->Wait.return_argument = size;
   5414e:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   54152:	2083           	movel %d3,%a0@                                    	<== NOT EXECUTED
   54154:	dffc 0000 000c 	addal #12,%sp                                     	<== 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))) {
   5415a:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5415c:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   5415e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   54160:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   54162:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   54164:	66dc           	bnes 54142 <_CORE_message_queue_Broadcast+0x3a>   	<== NOT EXECUTED
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_message_queue_mp_support) ( the_thread, id );
#endif

  }
  *count = number_broadcasted;
   54166:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
   5416a:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   5416c:	4cee 3c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a5                  	<== NOT EXECUTED
   54172:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_message_queue_mp_support) ( the_thread, id );
#endif

  }
  *count = number_broadcasted;
   54174:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   54176:	4e75           	rts                                               	<== NOT EXECUTED
   *        send and receive and this ensures that we are broadcasting
   *        the message to threads waiting to receive -- not to send.
   */

  if ( the_message_queue->number_of_pending_messages != 0 ) {
    *count = 0;
   54178:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
#endif

  }
  *count = number_broadcasted;
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   5417c:	4cee 3c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a5                  	<== NOT EXECUTED
   54182:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *        send and receive and this ensures that we are broadcasting
   *        the message to threads waiting to receive -- not to send.
   */

  if ( the_message_queue->number_of_pending_messages != 0 ) {
    *count = 0;
   54184:	4280           	clrl %d0                                          	<== NOT EXECUTED
   54186:	4290           	clrl %a0@                                         	<== NOT EXECUTED
#endif

  }
  *count = number_broadcasted;
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   54188:	4e75           	rts                                               	<== NOT EXECUTED
   5418a:	4cee 3c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a5                  	<== NOT EXECUTED
   54190:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
   54192:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
#endif

  }
  *count = number_broadcasted;
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   54194:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052d50 <_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
)
{
   52d50:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   52d54:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  /*
   *  This will flush blocked threads whether they were blocked on
   *  a send or receive.
   */

  _Thread_queue_Flush(
   52d56:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
void _CORE_message_queue_Close(
  CORE_message_queue_Control *the_message_queue,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   52d5a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  /*
   *  This will flush blocked threads whether they were blocked on
   *  a send or receive.
   */

  _Thread_queue_Flush(
   52d5e:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52d62:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   52d64:	4eb9 0004 ddd0 	jsr 4ddd0 <_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 )
   52d6a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52d70:	4aaa 0048      	tstl %a2@(72)                                     	<== NOT EXECUTED
   52d74:	6612           	bnes 52d88 <_CORE_message_queue_Close+0x38>       	<== NOT EXECUTED
    (void) _CORE_message_queue_Flush_support( the_message_queue );

  (void) _Workspace_Free( the_message_queue->message_buffers );
   52d76:	2d6a 005c 0008 	movel %a2@(92),%fp@(8)                            	<== NOT EXECUTED

}
   52d7c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   52d80:	4e5e           	unlk %fp                                          	<== 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 );
   52d82:	4ef9 0004 eb20 	jmp 4eb20 <_Workspace_Free>                       	<== NOT EXECUTED
   *  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 )
    (void) _CORE_message_queue_Flush_support( the_message_queue );
   52d88:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   52d8a:	4eb9 0005 2da4 	jsr 52da4 <_CORE_message_queue_Flush_support>     	<== NOT EXECUTED

  (void) _Workspace_Free( the_message_queue->message_buffers );
   52d90:	2d6a 005c 0008 	movel %a2@(92),%fp@(8)                            	<== NOT EXECUTED

}
   52d96:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   *  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 )
    (void) _CORE_message_queue_Flush_support( the_message_queue );
   52d9a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  (void) _Workspace_Free( the_message_queue->message_buffers );

}
   52d9c:	4e5e           	unlk %fp                                          	<== 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 );
   52d9e:	4ef9 0004 eb20 	jmp 4eb20 <_Workspace_Free>                       	<== NOT EXECUTED

000541ec <_CORE_message_queue_Flush>:
 */

uint32_t   _CORE_message_queue_Flush(
  CORE_message_queue_Control *the_message_queue
)
{
   541ec:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   541f0:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( the_message_queue->number_of_pending_messages != 0 )
   541f4:	4aa8 0048      	tstl %a0@(72)                                     	<== NOT EXECUTED
   541f8:	6606           	bnes 54200 <_CORE_message_queue_Flush+0x14>       	<== NOT EXECUTED
    return _CORE_message_queue_Flush_support( the_message_queue );
  else
    return 0;
}
   541fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   541fc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   541fe:	4e75           	rts                                               	<== 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 );
   54200:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
  else
    return 0;
}
   54204:	4e5e           	unlk %fp                                          	<== 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 );
   54206:	4ef9 0005 420c 	jmp 5420c <_CORE_message_queue_Flush_support>     	<== NOT EXECUTED

00052da4 <_CORE_message_queue_Flush_support>:
 */

uint32_t   _CORE_message_queue_Flush_support(
  CORE_message_queue_Control *the_message_queue
)
{
   52da4:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   52da8:	48d7 1c00      	moveml %a2-%a4,%sp@                               	<== 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 );
   52dac:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

uint32_t   _CORE_message_queue_Flush_support(
  CORE_message_queue_Control *the_message_queue
)
{
   52db2:	206e 0008      	moveal %fp@(8),%a0                                	<== 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 );
   52db6:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   52db8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   52dba:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    inactive_first      = the_message_queue->Inactive_messages.first;
    message_queue_first = the_message_queue->Pending_messages.first;
   52dbc:	2468 0050      	moveal %a0@(80),%a2                               	<== 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 );
    inactive_first      = the_message_queue->Inactive_messages.first;
   52dc0:	2668 0068      	moveal %a0@(104),%a3                              	<== NOT EXECUTED
    message_queue_first = the_message_queue->Pending_messages.first;
    message_queue_last  = the_message_queue->Pending_messages.last;
   52dc4:	2268 0058      	moveal %a0@(88),%a1                               	<== NOT EXECUTED

    the_message_queue->Inactive_messages.first = message_queue_first;
   52dc8:	214a 0068      	movel %a2,%a0@(104)                               	<== NOT EXECUTED
    message_queue_last->next = inactive_first;
    inactive_first->previous = message_queue_last;
    message_queue_first->previous          =
   52dcc:	49e8 0068      	lea %a0@(104),%a4                                 	<== 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;
   52dd0:	2028 0048      	movel %a0@(72),%d0                                	<== NOT EXECUTED
    message_queue_first = the_message_queue->Pending_messages.first;
    message_queue_last  = the_message_queue->Pending_messages.last;

    the_message_queue->Inactive_messages.first = message_queue_first;
    message_queue_last->next = inactive_first;
    inactive_first->previous = message_queue_last;
   52dd4:	2749 0004      	movel %a1,%a3@(4)                                 	<== NOT EXECUTED
    inactive_first      = the_message_queue->Inactive_messages.first;
    message_queue_first = the_message_queue->Pending_messages.first;
    message_queue_last  = the_message_queue->Pending_messages.last;

    the_message_queue->Inactive_messages.first = message_queue_first;
    message_queue_last->next = inactive_first;
   52dd8:	228b           	movel %a3,%a1@                                    	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   52dda:	43e8 0054      	lea %a0@(84),%a1                                  	<== NOT EXECUTED
    inactive_first->previous = message_queue_last;
    message_queue_first->previous          =
   52dde:	254c 0004      	movel %a4,%a2@(4)                                 	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   52de2:	49e8 0050      	lea %a0@(80),%a4                                  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   52de6:	2149 0050      	movel %a1,%a0@(80)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   52dea:	214c 0058      	movel %a4,%a0@(88)                                	<== 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;
    the_message_queue->number_of_pending_messages = 0;
   52dee:	42a8 0048      	clrl %a0@(72)                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   52df2:	42a8 0054      	clrl %a0@(84)                                     	<== NOT EXECUTED
  _ISR_Enable( level );
   52df6:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  return count;
}
   52df8:	4cd7 1c00      	moveml %sp@,%a2-%a4                               	<== NOT EXECUTED
   52dfc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   52dfe:	4e75           	rts

00054268 <_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
)
{
   54268:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   5426c:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   54270:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   54274:	222e 0014      	movel %fp@(20),%d1                                	<== NOT EXECUTED
   54278:	262e 0010      	movel %fp@(16),%d3                                	<== 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)) {
   5427c:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
)
{
  size_t message_buffering_required;
  size_t allocated_message_size;

  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
   5427e:	2543 0044      	movel %d3,%a2@(68)                                	<== 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)) {
   54282:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
{
  size_t message_buffering_required;
  size_t allocated_message_size;

  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
  the_message_queue->number_of_pending_messages = 0;
   54284:	42aa 0048      	clrl %a2@(72)                                     	<== NOT EXECUTED
  the_message_queue->maximum_message_size       = maximum_message_size;
   54288:	2541 004c      	movel %d1,%a2@(76)                                	<== NOT EXECUTED
  CORE_message_queue_Control        *the_message_queue,
  CORE_message_queue_Notify_Handler  the_handler,
  void                              *the_argument
)
{
  the_message_queue->notify_handler  = the_handler;
   5428c:	42aa 0060      	clrl %a2@(96)                                     	<== NOT EXECUTED
  the_message_queue->notify_argument = the_argument;
   54290:	42aa 0064      	clrl %a2@(100)                                    	<== 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)) {
   54294:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   54296:	6620           	bnes 542b8 <_CORE_message_queue_Initialize+0x50>  	<== NOT EXECUTED
   54298:	2001           	movel %d1,%d0                                     	<== 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 *
   5429a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5429c:	0682 0000 0014 	addil #20,%d2                                     	<== NOT EXECUTED
   542a2:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   542a4:	4c03 1800      	mulsl %d3,%d1                                     	<== NOT EXECUTED
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));

  if (message_buffering_required < allocated_message_size)
   542a8:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   542aa:	631c           	blss 542c8 <_CORE_message_queue_Initialize+0x60>  	<== NOT EXECUTED
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
  );

  return true;
   542ac:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   542ae:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   542b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   542b6:	4e75           	rts                                               	<== NOT EXECUTED
   *  check for overflow on adding overhead to each message.
   */

  allocated_message_size = maximum_message_size;
  if (allocated_message_size & (sizeof(uint32_t) - 1)) {
      allocated_message_size += sizeof(uint32_t);
   542b8:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   542ba:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
      allocated_message_size &= ~(sizeof(uint32_t) - 1);
   542bc:	74fc           	moveq #-4,%d2                                     	<== NOT EXECUTED
   542be:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
  }

  if (allocated_message_size < maximum_message_size)
   542c0:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   542c2:	64d6           	bccs 5429a <_CORE_message_queue_Initialize+0x32>  	<== NOT EXECUTED
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
  );

  return true;
   542c4:	4200           	clrb %d0                                          	<== NOT EXECUTED
   542c6:	60e6           	bras 542ae <_CORE_message_queue_Initialize+0x46>  	<== NOT EXECUTED
    return false;

  /*
   *  Attempt to allocate the message memory
   */
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
   542c8:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   542ca:	4eb9 0005 7a94 	jsr 57a94 <_Workspace_Allocate>                   	<== NOT EXECUTED
     _Workspace_Allocate( message_buffering_required );

  if (the_message_queue->message_buffers == 0)
   542d0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    return false;

  /*
   *  Attempt to allocate the message memory
   */
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
   542d2:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
     _Workspace_Allocate( message_buffering_required );

  if (the_message_queue->message_buffers == 0)
   542d6:	67d4           	beqs 542ac <_CORE_message_queue_Initialize+0x44>  	<== NOT EXECUTED

  /*
   *  Initialize the pool of inactive messages, pending messages,
   *  and set of waiting threads.
   */
  _Chain_Initialize (
   542d8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   542da:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   542dc:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   542de:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   542e2:	4eb9 0005 40a8 	jsr 540a8 <_Chain_Initialize>                     	<== NOT EXECUTED
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );

  _Chain_Initialize_empty( &the_message_queue->Pending_messages );

  _Thread_queue_Initialize(
   542e8:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   542ec:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   542f0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   542f2:	b090           	cmpl %a0@,%d0                                     	<== NOT EXECUTED
   542f4:	57c0           	seq %d0                                           	<== NOT EXECUTED
   542f6:	4878 0080      	pea 80 <FP_REGS_SAVED+0x40>                       	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   542fa:	41ea 0054      	lea %a2@(84),%a0                                  	<== NOT EXECUTED
   542fe:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   54300:	2548 0050      	movel %a0,%a2@(80)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   54304:	41ea 0050      	lea %a2@(80),%a0                                  	<== NOT EXECUTED
   54308:	4480           	negl %d0                                          	<== NOT EXECUTED
   5430a:	2548 0058      	movel %a0,%a2@(88)                                	<== NOT EXECUTED
   5430e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   54310:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   54312:	42aa 0054      	clrl %a2@(84)                                     	<== NOT EXECUTED
   54316:	4eb9 0005 6ac4 	jsr 56ac4 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   5431c:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
    STATES_WAITING_FOR_MESSAGE,
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
  );

  return true;
}
   54322:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   54328:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );

  _Chain_Initialize_empty( &the_message_queue->Pending_messages );

  _Thread_queue_Initialize(
   5432a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    STATES_WAITING_FOR_MESSAGE,
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
  );

  return true;
}
   5432c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00055e30 <_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
)
{
   55e30:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   55e34:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   55e38:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   55e3c:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   55e40:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  ISR_Level  level;
  bool       notify = false;

  the_message->priority = submit_type;
   55e44:	2540 0008      	movel %d0,%a2@(8)                                 	<== NOT EXECUTED

  switch ( submit_type ) {
   55e48:	0c80 8000 0000 	cmpil #-2147483648,%d0                            	<== NOT EXECUTED
   55e4e:	6700 00b4      	beqw 55f04 <_CORE_message_queue_Insert_message+0xd4>	<== NOT EXECUTED
   55e52:	0c80 7fff ffff 	cmpil #2147483647,%d0                             	<== NOT EXECUTED
   55e58:	6768           	beqs 55ec2 <_CORE_message_queue_Insert_message+0x92>	<== 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;
   55e5a:	206b 0050      	moveal %a3@(80),%a0                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   55e5e:	220b           	movel %a3,%d1                                     	<== NOT EXECUTED
   55e60:	0681 0000 0054 	addil #84,%d1                                     	<== NOT EXECUTED
        while ( !_Chain_Is_tail( the_header, the_node ) ) {
   55e66:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   55e68:	670c           	beqs 55e76 <_CORE_message_queue_Insert_message+0x46>	<== NOT EXECUTED

          this_message = (CORE_message_queue_Buffer_control *) the_node;

          if ( this_message->priority <= the_message->priority ) {
   55e6a:	b0a8 0008      	cmpl %a0@(8),%d0                                  	<== NOT EXECUTED
   55e6e:	6d08           	blts 55e78 <_CORE_message_queue_Insert_message+0x48>	<== NOT EXECUTED
            the_node = the_node->next;
   55e70:	2050           	moveal %a0@,%a0                                   	<== 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 ) ) {
   55e72:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   55e74:	66f4           	bnes 55e6a <_CORE_message_queue_Insert_message+0x3a>	<== NOT EXECUTED
   55e76:	2041           	moveal %d1,%a0                                    	<== NOT EXECUTED
            continue;
          }

          break;
        }
        _ISR_Disable( level );
   55e78:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   55e7e:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   55e80:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   55e82:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
          if ( the_message_queue->number_of_pending_messages++ == 0 )
            notify = true;
          _Chain_Insert_unprotected( the_node->previous, &the_message->Node );
   55e84:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   55e88:	2250           	moveal %a0@,%a1                                   	<== NOT EXECUTED
          }

          break;
        }
        _ISR_Disable( level );
          if ( the_message_queue->number_of_pending_messages++ == 0 )
   55e8a:	222b 0048      	movel %a3@(72),%d1                                	<== NOT EXECUTED
  after_node->next      = the_node;
   55e8e:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
   55e90:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   55e92:	57c0           	seq %d0                                           	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   55e94:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   55e98:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   55e9a:	4480           	negl %d0                                          	<== NOT EXECUTED
   55e9c:	2741 0048      	movel %d1,%a3@(72)                                	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
   55ea0:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
   55ea4:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
            notify = true;
          _Chain_Insert_unprotected( the_node->previous, &the_message->Node );
        _ISR_Enable( level );
   55ea6:	46c2           	movew %d2,%sr                                     	<== 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 )
   55ea8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   55eaa:	6750           	beqs 55efc <_CORE_message_queue_Insert_message+0xcc>	<== NOT EXECUTED
   55eac:	202b 0060      	movel %a3@(96),%d0                                	<== NOT EXECUTED
   55eb0:	674a           	beqs 55efc <_CORE_message_queue_Insert_message+0xcc>	<== NOT EXECUTED
    (*the_message_queue->notify_handler)( the_message_queue->notify_argument );
   55eb2:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   55eb4:	2d6b 0064 0008 	movel %a3@(100),%fp@(8)                           	<== NOT EXECUTED
}
   55eba:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   55ebe:	4e5e           	unlk %fp                                          	<== 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 );
   55ec0:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED

  the_message->priority = submit_type;

  switch ( submit_type ) {
    case CORE_MESSAGE_QUEUE_SEND_REQUEST:
      _ISR_Disable( level );
   55ec2:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   55ec8:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   55eca:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   55ecc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
        if ( the_message_queue->number_of_pending_messages++ == 0 )
   55ece:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   55ed2:	41eb 0054      	lea %a3@(84),%a0                                  	<== NOT EXECUTED
   55ed6:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   55ed8:	206b 0058      	moveal %a3@(88),%a0                               	<== NOT EXECUTED
   55edc:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   55ede:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   55ee0:	2741 0048      	movel %d1,%a3@(72)                                	<== NOT EXECUTED
   55ee4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   55ee6:	57c1           	seq %d1                                           	<== NOT EXECUTED
  the_chain->last     = the_node;
   55ee8:	274a 0058      	movel %a2,%a3@(88)                                	<== NOT EXECUTED
   55eec:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   55eee:	4480           	negl %d0                                          	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   55ef0:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   55ef4:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
          notify = true;
        _CORE_message_queue_Append_unprotected(the_message_queue, the_message);
      _ISR_Enable( level );
   55ef6:	46c2           	movew %d2,%sr                                     	<== 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 )
   55ef8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   55efa:	66b0           	bnes 55eac <_CORE_message_queue_Insert_message+0x7c>	<== NOT EXECUTED
    (*the_message_queue->notify_handler)( the_message_queue->notify_argument );
}
   55efc:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   55f00:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   55f02:	4e75           	rts                                               	<== NOT EXECUTED
          notify = true;
        _CORE_message_queue_Append_unprotected(the_message_queue, the_message);
      _ISR_Enable( level );
      break;
    case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
      _ISR_Disable( level );
   55f04:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   55f0a:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   55f0c:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   55f0e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
        if ( the_message_queue->number_of_pending_messages++ == 0 )
   55f10:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
   55f14:	41eb 0050      	lea %a3@(80),%a0                                  	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   55f18:	2250           	moveal %a0@,%a1                                   	<== NOT EXECUTED
   55f1a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  after_node->next      = the_node;
   55f1c:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
   55f1e:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   55f20:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   55f24:	2741 0048      	movel %d1,%a3@(72)                                	<== NOT EXECUTED
   55f28:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   55f2a:	57c1           	seq %d1                                           	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
   55f2c:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
   55f30:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   55f32:	4480           	negl %d0                                          	<== NOT EXECUTED
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
   55f34:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
          notify = true;
        _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
      _ISR_Enable( level );
   55f36:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   55f38:	6000 ff6e      	braw 55ea8 <_CORE_message_queue_Insert_message+0x78>	<== NOT EXECUTED

00052e00 <_CORE_message_queue_Seize>:
  void                            *buffer,
  size_t                          *size_p,
  bool                             wait,
  Watchdog_Interval                timeout
)
{
   52e00:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   52e04:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
   52e08:	286e 000c      	moveal %fp@(12),%a4                               	<== NOT EXECUTED
   52e0c:	282e 001c      	movel %fp@(28),%d4                                	<== NOT EXECUTED
  ISR_Level                          level;
  CORE_message_queue_Buffer_control *the_message;
  Thread_Control                    *executing;
  Thread_Control                    *the_thread;

  executing = _Thread_Executing;
   52e10:	2079 0006 6c9a 	moveal 66c9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   52e16:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
  CORE_message_queue_Buffer_control *the_message;
  Thread_Control                    *executing;
  Thread_Control                    *the_thread;

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
   52e1c:	42a8 0034      	clrl %a0@(52)                                     	<== NOT EXECUTED
  void                            *buffer,
  size_t                          *size_p,
  bool                             wait,
  Watchdog_Interval                timeout
)
{
   52e20:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   52e24:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   52e28:	226e 0014      	moveal %fp@(20),%a1                               	<== NOT EXECUTED
   52e2c:	242e 0018      	movel %fp@(24),%d2                                	<== NOT EXECUTED
  Thread_Control                    *executing;
  Thread_Control                    *the_thread;

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   52e30:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   52e32:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   52e34:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   52e36:	246b 0050      	moveal %a3@(80),%a2                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   52e3a:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   52e3c:	0680 0000 0054 	addil #84,%d0                                     	<== NOT EXECUTED
   52e42:	b08a           	cmpl %a2,%d0                                      	<== NOT EXECUTED
   52e44:	6700 008c      	beqw 52ed2 <_CORE_message_queue_Seize+0xd2>       	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   52e48:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   52e4a:	2748 0050      	movel %a0,%a3@(80)                                	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   52e4e:	49eb 0050      	lea %a3@(80),%a4                                  	<== NOT EXECUTED
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {
    the_message_queue->number_of_pending_messages -= 1;
   52e52:	53ab 0048      	subql #1,%a3@(72)                                 	<== NOT EXECUTED
   52e56:	214c 0004      	movel %a4,%a0@(4)                                 	<== NOT EXECUTED
    _ISR_Enable( level );
   52e5a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

    *size_p = the_message->Contents.size;
    _Thread_Executing->Wait.count = the_message->priority;
   52e5c:	2079 0006 6c9a 	moveal 66c9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {
    the_message_queue->number_of_pending_messages -= 1;
    _ISR_Enable( level );

    *size_p = the_message->Contents.size;
   52e62:	22aa 000c      	movel %a2@(12),%a1@                               	<== NOT EXECUTED
    _Thread_Executing->Wait.count = the_message->priority;
    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
   52e66:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
  if ( the_message != NULL ) {
    the_message_queue->number_of_pending_messages -= 1;
    _ISR_Enable( level );

    *size_p = the_message->Contents.size;
    _Thread_Executing->Wait.count = the_message->priority;
   52e68:	216a 0008 0024 	movel %a2@(8),%a0@(36)                            	<== NOT EXECUTED
    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
   52e6e:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   52e74:	2f11           	movel %a1@,%sp@-                                  	<== NOT EXECUTED
   52e76:	49f9 0005 7b5c 	lea 57b5c <memcpy>,%a4                            	<== NOT EXECUTED
   52e7c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52e7e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   52e80:	4e94           	jsr %a4@                                          	<== 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 );
   52e82:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   52e84:	4eb9 0004 d9e8 	jsr 4d9e8 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
    if ( !the_thread ) {
   52e8a:	dffc 0000 0010 	addal #16,%sp                                     	<== 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 );
   52e90:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
    if ( !the_thread ) {
   52e92:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   52e94:	6700 008a      	beqw 52f20 <_CORE_message_queue_Seize+0x120>      	<== NOT EXECUTED
     *  puts the messages in the message queue on behalf of the
     *  waiting task.
     */

    the_message->priority  = the_thread->Wait.count;
    the_message->Contents.size = (size_t) the_thread->Wait.option;
   52e98:	2028 0030      	movel %a0@(48),%d0                                	<== 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;
   52e9c:	2568 0024 0008 	movel %a0@(36),%a2@(8)                            	<== NOT EXECUTED
    the_message->Contents.size = (size_t) the_thread->Wait.option;
   52ea2:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
   52ea6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   52ea8:	2f28 002c      	movel %a0@(44),%sp@-                              	<== NOT EXECUTED
   52eac:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52eae:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
      the_thread->Wait.return_argument_second.immutable_object,
      the_message->Contents.buffer,
      the_message->Contents.size
    );

    _CORE_message_queue_Insert_message(
   52eb0:	2d6a 0008 0010 	movel %a2@(8),%fp@(16)                            	<== NOT EXECUTED
   52eb6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52ebc:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   52ec0:	2d4b 0008      	movel %a3,%fp@(8)                                 	<== 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 );
}
   52ec4:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   52eca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      the_thread->Wait.return_argument_second.immutable_object,
      the_message->Contents.buffer,
      the_message->Contents.size
    );

    _CORE_message_queue_Insert_message(
   52ecc:	4ef9 0005 5e30 	jmp 55e30 <_CORE_message_queue_Insert_message>    	<== NOT EXECUTED
       the_message->priority
    );
    return;
  }

  if ( !wait ) {
   52ed2:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   52ed4:	6612           	bnes 52ee8 <_CORE_message_queue_Seize+0xe8>       	<== NOT EXECUTED
    _ISR_Enable( level );
   52ed6:	46c1           	movew %d1,%sr                                     	<== 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 );
}
   52ed8:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
    return;
  }

  if ( !wait ) {
    _ISR_Enable( level );
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
   52ede:	7004           	moveq #4,%d0                                      	<== 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 );
}
   52ee0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return;
  }

  if ( !wait ) {
    _ISR_Enable( level );
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
   52ee2:	2140 0034      	movel %d0,%a0@(52)                                	<== 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 );
}
   52ee6:	4e75           	rts                                               	<== NOT EXECUTED
   52ee8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   52eea:	2740 0030      	movel %d0,%a3@(48)                                	<== NOT EXECUTED

  _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
  executing->Wait.queue = &the_message_queue->Wait_queue;
  executing->Wait.id = id;
  executing->Wait.return_argument_second.mutable_object = buffer;
  executing->Wait.return_argument = size_p;
   52eee:	2149 0028      	movel %a1,%a0@(40)                                	<== NOT EXECUTED
    return;
  }

  _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
  executing->Wait.queue = &the_message_queue->Wait_queue;
  executing->Wait.id = id;
   52ef2:	214c 0020      	movel %a4,%a0@(32)                                	<== NOT EXECUTED
  executing->Wait.return_argument_second.mutable_object = buffer;
   52ef6:	2143 002c      	movel %d3,%a0@(44)                                	<== 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;
   52efa:	214b 0044      	movel %a3,%a0@(68)                                	<== NOT EXECUTED
  executing->Wait.id = id;
  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 );
   52efe:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
   52f00:	49f9 0004 df10 	lea 4df10 <_Thread_queue_Timeout>,%a4             	<== NOT EXECUTED
   52f06:	2d44 000c      	movel %d4,%fp@(12)                                	<== NOT EXECUTED
   52f0a:	2d4c 0010      	movel %a4,%fp@(16)                                	<== NOT EXECUTED
   52f0e:	2d4b 0008      	movel %a3,%fp@(8)                                 	<== NOT EXECUTED
}
   52f12:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   52f18:	4e5e           	unlk %fp                                          	<== 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 );
   52f1a:	4ef9 0004 db50 	jmp 4db50 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
    CORE_message_queue_Control        *the_message_queue,
    CORE_message_queue_Buffer_control *the_message
)
{
  _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
   52f20:	d7fc 0000 0068 	addal #104,%a3                                    	<== NOT EXECUTED
   52f26:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   52f2a:	2d4b 0008      	movel %a3,%fp@(8)                                 	<== NOT EXECUTED
}
   52f2e:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   52f34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   52f36:	4ef9 0004 bf2c 	jmp 4bf2c <_Chain_Append>                         	<== NOT EXECUTED

00052f3c <_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
)
{
   52f3c:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   52f40:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
   52f44:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   52f48:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   52f4c:	142e 0023      	moveb %fp@(35),%d2                                	<== NOT EXECUTED
  ISR_Level                            level;
  CORE_message_queue_Buffer_control   *the_message;
  Thread_Control                      *the_thread;

  if ( size > the_message_queue->maximum_message_size ) {
   52f50:	b6ab 004c      	cmpl %a3@(76),%d3                                 	<== NOT EXECUTED
   52f54:	627c           	bhis 52fd2 <_CORE_message_queue_Submit+0x96>      	<== NOT EXECUTED

  /*
   *  Is there a thread currently waiting on this message queue?
   */

  if ( the_message_queue->number_of_pending_messages == 0 ) {
   52f56:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
   52f5a:	6700 0082      	beqw 52fde <_CORE_message_queue_Submit+0xa2>      	<== 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 <
   52f5e:	b0ab 0044      	cmpl %a3@(68),%d0                                 	<== NOT EXECUTED
   52f62:	6500 00d4      	bcsw 53038 <_CORE_message_queue_Submit+0xfc>      	<== 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 ) {
   52f66:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   52f68:	6700 00b6      	beqw 53020 <_CORE_message_queue_Submit+0xe4>      	<== 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() ) {
   52f6c:	2039 0006 6c7a 	movel 66c7a <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   52f72:	6600 00b8      	bnew 5302c <_CORE_message_queue_Submit+0xf0>      	<== NOT EXECUTED
   */

  {
    Thread_Control  *executing = _Thread_Executing;

    _ISR_Disable( level );
   52f76:	223c 0000 0700 	movel #1792,%d1                                   	<== 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;
   52f7c:	2079 0006 6c9a 	moveal 66c9a <_Thread_Executing>,%a0              	<== NOT EXECUTED

    _ISR_Disable( level );
   52f82:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   52f84:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   52f86:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   52f88:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   52f8a:	2741 0030      	movel %d1,%a3@(48)                                	<== NOT EXECUTED
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
    executing->Wait.id = id;
    executing->Wait.return_argument_second.immutable_object = buffer;
    executing->Wait.option = (uint32_t) size;
    executing->Wait.count = submit_type;
   52f8e:	222e 001c      	movel %fp@(28),%d1                                	<== NOT EXECUTED
    Thread_Control  *executing = _Thread_Executing;

    _ISR_Disable( level );
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
    executing->Wait.id = id;
   52f92:	216e 0014 0020 	movel %fp@(20),%a0@(32)                           	<== NOT EXECUTED
    executing->Wait.return_argument_second.immutable_object = buffer;
    executing->Wait.option = (uint32_t) size;
    executing->Wait.count = submit_type;
   52f98:	2141 0024      	movel %d1,%a0@(36)                                	<== NOT EXECUTED

    _ISR_Disable( level );
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
    executing->Wait.id = id;
    executing->Wait.return_argument_second.immutable_object = buffer;
   52f9c:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
    executing->Wait.option = (uint32_t) size;
   52fa0:	2143 0030      	movel %d3,%a0@(48)                                	<== NOT EXECUTED

    _ISR_Disable( level );
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
    executing->Wait.id = id;
    executing->Wait.return_argument_second.immutable_object = buffer;
   52fa4:	2141 002c      	movel %d1,%a0@(44)                                	<== NOT EXECUTED
  {
    Thread_Control  *executing = _Thread_Executing;

    _ISR_Disable( level );
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
   52fa8:	214b 0044      	movel %a3,%a0@(68)                                	<== NOT EXECUTED
    executing->Wait.id = id;
    executing->Wait.return_argument_second.immutable_object = buffer;
    executing->Wait.option = (uint32_t) size;
    executing->Wait.count = submit_type;
    _ISR_Enable( level );
   52fac:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
   52fae:	4879 0004 df10 	pea 4df10 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   52fb4:	2f2e 0024      	movel %fp@(36),%sp@-                              	<== NOT EXECUTED
   52fb8:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   52fba:	4eb9 0004 db50 	jsr 4db50 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
   52fc0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   52fc6:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   52fcc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    executing->Wait.return_argument_second.immutable_object = buffer;
    executing->Wait.option = (uint32_t) size;
    executing->Wait.count = submit_type;
    _ISR_Enable( level );

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
   52fce:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   52fd0:	4e75           	rts                                               	<== NOT EXECUTED
   52fd2:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   52fd8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  ISR_Level                            level;
  CORE_message_queue_Buffer_control   *the_message;
  Thread_Control                      *the_thread;

  if ( size > the_message_queue->maximum_message_size ) {
   52fda:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   52fdc:	4e75           	rts                                               	<== NOT EXECUTED
  /*
   *  Is there a thread currently waiting on this message queue?
   */

  if ( the_message_queue->number_of_pending_messages == 0 ) {
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
   52fde:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   52fe0:	4eb9 0004 d9e8 	jsr 4d9e8 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
    if ( the_thread ) {
   52fe6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  /*
   *  Is there a thread currently waiting on this message queue?
   */

  if ( the_message_queue->number_of_pending_messages == 0 ) {
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
   52fe8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
    if ( the_thread ) {
   52fea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   52fec:	6700 0096      	beqw 53084 <_CORE_message_queue_Submit+0x148>     	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   52ff0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   52ff2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52ff6:	2f2a 002c      	movel %a2@(44),%sp@-                              	<== NOT EXECUTED
   52ffa:	4eb9 0005 7b5c 	jsr 57b5c <memcpy>                                	<== 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;
   53000:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
      the_thread->Wait.count = submit_type;
   53004:	222e 001c      	movel %fp@(28),%d1                                	<== 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;
   53008:	2083           	movel %d3,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = submit_type;
   5300a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   53010:	4280           	clrl %d0                                          	<== NOT EXECUTED
   53012:	2541 0024      	movel %d1,%a2@(36)                                	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   53016:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   5301c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5301e:	4e75           	rts                                               	<== NOT EXECUTED
   53020:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   53026:	4e5e           	unlk %fp                                          	<== 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 ) {
   53028:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   5302a:	4e75           	rts                                               	<== NOT EXECUTED
   5302c:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   53032:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _ISR_Enable( level );

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
   53034:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
}
   53036:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control *
_CORE_message_queue_Allocate_message_buffer (
    CORE_message_queue_Control *the_message_queue
)
{
   return (CORE_message_queue_Buffer_control *)
   53038:	486b 0068      	pea %a3@(104)                                     	<== NOT EXECUTED
   5303c:	4eb9 0004 bf64 	jsr 4bf64 <_Chain_Get>                            	<== NOT EXECUTED

    /*
     *  NOTE: If the system is consistent, this error should never occur.
     */

    if ( !the_message ) {
   53042:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   53044:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   53046:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   53048:	67e2           	beqs 5302c <_CORE_message_queue_Submit+0xf0>      	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   5304a:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5304c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   53050:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   53054:	4eb9 0005 7b5c 	jsr 57b5c <memcpy>                                	<== NOT EXECUTED
      buffer,
      the_message->Contents.buffer,
      size
    );
    the_message->Contents.size = size;
    the_message->priority  = submit_type;
   5305a:	202e 001c      	movel %fp@(28),%d0                                	<== NOT EXECUTED
    _CORE_message_queue_Copy_buffer(
      buffer,
      the_message->Contents.buffer,
      size
    );
    the_message->Contents.size = size;
   5305e:	2543 000c      	movel %d3,%a2@(12)                                	<== NOT EXECUTED
    the_message->priority  = submit_type;
   53062:	2540 0008      	movel %d0,%a2@(8)                                 	<== NOT EXECUTED

    _CORE_message_queue_Insert_message(
   53066:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   53068:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5306a:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5306c:	4eb9 0005 5e30 	jsr 55e30 <_CORE_message_queue_Insert_message>    	<== NOT EXECUTED
   53072:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   53078:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   5307e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      size
    );
    the_message->Contents.size = size;
    the_message->priority  = submit_type;

    _CORE_message_queue_Insert_message(
   53080:	4280           	clrl %d0                                          	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
   53082:	4e75           	rts                                               	<== NOT EXECUTED
   *  Is there a thread currently waiting on this message queue?
   */

  if ( the_message_queue->number_of_pending_messages == 0 ) {
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
    if ( the_thread ) {
   53084:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
   53088:	6000 fed4      	braw 52f5e <_CORE_message_queue_Submit+0x22>      	<== NOT EXECUTED

00046710 <_CORE_mutex_Flush>:
void _CORE_mutex_Flush(
  CORE_mutex_Control         *the_mutex,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   46710:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Thread_queue_Flush(
    &the_mutex->Wait_queue,
    remote_extract_callout,
    status
  );
}
   46714:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  CORE_mutex_Control         *the_mutex,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
  _Thread_queue_Flush(
   46716:	4ef9 0004 84a0 	jmp 484a0 <_Thread_queue_Flush>                   	<== NOT EXECUTED

0004671c <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
  CORE_mutex_Control           *the_mutex,
  CORE_mutex_Attributes        *the_mutex_attributes,
  uint32_t                      initial_lock
)
{
   4671c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46720:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46722:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   46726:	226e 0008      	moveal %fp@(8),%a1                                	<== 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;
   4672a:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   4672c:	2358 0040      	movel %a0@+,%a1@(64)                              	<== NOT EXECUTED
CORE_mutex_Status _CORE_mutex_Initialize(
  CORE_mutex_Control           *the_mutex,
  CORE_mutex_Attributes        *the_mutex_attributes,
  uint32_t                      initial_lock
)
{
   46730:	202e 0010      	movel %fp@(16),%d0                                	<== 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;
   46734:	2358 0044      	movel %a0@+,%a1@(68)                              	<== NOT EXECUTED
   46738:	2358 0048      	movel %a0@+,%a1@(72)                              	<== NOT EXECUTED
   4673c:	3350 004c      	movew %a0@,%a1@(76)                               	<== NOT EXECUTED
  the_mutex->lock          = initial_lock;
   46740:	2340 004e      	movel %d0,%a1@(78)                                	<== NOT EXECUTED
  the_mutex->blocked_count = 0;
   46744:	42a9 0056      	clrl %a1@(86)                                     	<== NOT EXECUTED

  if ( initial_lock == CORE_MUTEX_LOCKED ) {
   46748:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4674a:	6656           	bnes 467a2 <_CORE_mutex_Initialize+0x86>          	<== NOT EXECUTED
    the_mutex->nest_count = 1;
    the_mutex->holder     = _Thread_Executing;
   4674c:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
  the_mutex->Attributes    = *the_mutex_attributes;
  the_mutex->lock          = initial_lock;
  the_mutex->blocked_count = 0;

  if ( initial_lock == CORE_MUTEX_LOCKED ) {
    the_mutex->nest_count = 1;
   46752:	103c 0001      	moveb #1,%d0                                      	<== NOT EXECUTED
   46756:	2340 0052      	movel %d0,%a1@(82)                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
  CORE_mutex_Attributes *the_attribute
)
{
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
   4675a:	2029 0046      	movel %a1@(70),%d0                                	<== NOT EXECUTED
    the_mutex->holder     = _Thread_Executing;
    the_mutex->holder_id  = _Thread_Executing->Object.id;
   4675e:	2368 0008 005e 	movel %a0@(8),%a1@(94)                            	<== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   46764:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
  the_mutex->lock          = initial_lock;
  the_mutex->blocked_count = 0;

  if ( initial_lock == CORE_MUTEX_LOCKED ) {
    the_mutex->nest_count = 1;
    the_mutex->holder     = _Thread_Executing;
   46766:	2348 005a      	movel %a0,%a1@(90)                                	<== NOT EXECUTED
    the_mutex->holder_id  = _Thread_Executing->Object.id;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4676a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4676c:	6766           	beqs 467d4 <_CORE_mutex_Initialize+0xb8>          	<== NOT EXECUTED
   4676e:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   46772:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46774:	675e           	beqs 467d4 <_CORE_mutex_Initialize+0xb8>          	<== NOT EXECUTED
    the_mutex->nest_count = 0;
    the_mutex->holder     = NULL;
    the_mutex->holder_id  = 0;
  }

  _Thread_queue_Initialize(
   46776:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   4677a:	4aaa 0006      	tstl %a2@(6)                                      	<== NOT EXECUTED
   4677e:	56c0           	sne %d0                                           	<== NOT EXECUTED
   46780:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   46784:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   46786:	4480           	negl %d0                                          	<== NOT EXECUTED
   46788:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4678a:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   4678c:	4eb9 0004 84dc 	jsr 484dc <_Thread_queue_Initialize>              	<== NOT EXECUTED
   46792:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   46798:	4280           	clrl %d0                                          	<== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,
    CORE_MUTEX_TIMEOUT
  );

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   4679a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4679e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   467a0:	4e75           	rts                                               	<== NOT EXECUTED
#endif

      _Thread_Executing->resource_count++;
    }
  } else {
    the_mutex->nest_count = 0;
   467a2:	42a9 0052      	clrl %a1@(82)                                     	<== NOT EXECUTED
    the_mutex->holder     = NULL;
   467a6:	42a9 005a      	clrl %a1@(90)                                     	<== NOT EXECUTED
    the_mutex->holder_id  = 0;
   467aa:	42a9 005e      	clrl %a1@(94)                                     	<== NOT EXECUTED
  }

  _Thread_queue_Initialize(
   467ae:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   467b2:	4aaa 0006      	tstl %a2@(6)                                      	<== NOT EXECUTED
   467b6:	56c0           	sne %d0                                           	<== NOT EXECUTED
   467b8:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   467bc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   467be:	4480           	negl %d0                                          	<== NOT EXECUTED
   467c0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   467c2:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   467c4:	4eb9 0004 84dc 	jsr 484dc <_Thread_queue_Initialize>              	<== NOT EXECUTED
   467ca:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   467d0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   467d2:	60c6           	bras 4679a <_CORE_mutex_Initialize+0x7e>          	<== NOT EXECUTED
    the_mutex->holder     = _Thread_Executing;
    the_mutex->holder_id  = _Thread_Executing->Object.id;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {

      if ( _Thread_Executing->current_priority <
   467d4:	2029 004a      	movel %a1@(74),%d0                                	<== NOT EXECUTED
   467d8:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   467dc:	622a           	bhis 46808 <_CORE_mutex_Initialize+0xec>          	<== 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++;
   467de:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
    the_mutex->nest_count = 0;
    the_mutex->holder     = NULL;
    the_mutex->holder_id  = 0;
  }

  _Thread_queue_Initialize(
   467e2:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   467e6:	4aaa 0006      	tstl %a2@(6)                                      	<== NOT EXECUTED
   467ea:	56c0           	sne %d0                                           	<== NOT EXECUTED
   467ec:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   467f0:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   467f2:	4480           	negl %d0                                          	<== NOT EXECUTED
   467f4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   467f6:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   467f8:	4eb9 0004 84dc 	jsr 484dc <_Thread_queue_Initialize>              	<== NOT EXECUTED
   467fe:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   46804:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46806:	6092           	bras 4679a <_CORE_mutex_Initialize+0x7e>          	<== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,
    CORE_MUTEX_TIMEOUT
  );

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46808:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4680c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    the_mutex->holder     = _Thread_Executing;
    the_mutex->holder_id  = _Thread_Executing->Object.id;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {

      if ( _Thread_Executing->current_priority <
   4680e:	7006           	moveq #6,%d0                                      	<== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,
    CORE_MUTEX_TIMEOUT
  );

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46810:	4e75           	rts                                               	<== NOT EXECUTED
	...

000468a6 <_CORE_mutex_Seize>:
  Objects_Id           _id,
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
   468a6:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   468aa:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   468ac:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   468b0:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   468b4:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
  Objects_Id           _id,
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
   468ba:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   468bc:	1401           	moveb %d1,%d2                                     	<== NOT EXECUTED
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   468be:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   468c0:	6704           	beqs 468c6 <_CORE_mutex_Seize+0x20>               	<== NOT EXECUTED
   468c2:	4a01           	tstb %d1                                          	<== NOT EXECUTED
   468c4:	6634           	bnes 468fa <_CORE_mutex_Seize+0x54>               	<== NOT EXECUTED
   468c6:	486e 0018      	pea %fp@(24)                                      	<== NOT EXECUTED
   468ca:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   468cc:	4eb9 0004 b294 	jsr 4b294 <_CORE_mutex_Seize_interrupt_trylock>   	<== NOT EXECUTED
   468d2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   468d4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   468d6:	6716           	beqs 468ee <_CORE_mutex_Seize+0x48>               	<== NOT EXECUTED
   468d8:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   468da:	6636           	bnes 46912 <_CORE_mutex_Seize+0x6c>               	<== NOT EXECUTED
   468dc:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED
   468e0:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   468e2:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   468e8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   468ea:	2141 0034      	movel %d1,%a0@(52)                                	<== NOT EXECUTED
}
   468ee:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   468f2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   468f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   468f8:	4e75           	rts                                               	<== NOT EXECUTED
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   468fa:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   468fc:	b0b9 0005 88e6 	cmpl 588e6 <_System_state_Current>,%d0            	<== NOT EXECUTED
   46902:	64c2           	bccs 468c6 <_CORE_mutex_Seize+0x20>               	<== NOT EXECUTED
   46904:	4878 0013      	pea 13 <FP_STATE_SAVED+0x3>                       	<== NOT EXECUTED
   46908:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4690a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4690c:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
   46912:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46918:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4691e:	216e 000c 0020 	movel %fp@(12),%a0@(32)                           	<== NOT EXECUTED
   46924:	5280           	addql #1,%d0                                      	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   46926:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46928:	2541 0030      	movel %d1,%a2@(48)                                	<== NOT EXECUTED
   4692c:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   46932:	214a 0044      	movel %a2,%a0@(68)                                	<== NOT EXECUTED
   46936:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED
   4693a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4693c:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   46940:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46942:	4eb9 0004 6814 	jsr 46814 <_CORE_mutex_Seize_interrupt_blocking>  	<== NOT EXECUTED
}
   46948:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4694c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   46950:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   46952:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46954:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046814 <_CORE_mutex_Seize_interrupt_blocking>:

void _CORE_mutex_Seize_interrupt_blocking(
  CORE_mutex_Control  *the_mutex,
  Watchdog_Interval    timeout
)
{
   46814:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46818:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4681a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4681e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46820:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Thread_Control   *executing;

  executing = _Thread_Executing;
   46824:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {
   4682a:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4682c:	b0aa 0046      	cmpl %a2@(70),%d0                                 	<== NOT EXECUTED
   46830:	672a           	beqs 4685c <_CORE_mutex_Seize_interrupt_blocking+0x48>	<== NOT EXECUTED
      );
    }
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   46832:	4879 0004 85e0 	pea 485e0 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
        FALSE
      );
    }
  }

  the_mutex->blocked_count++;
   46838:	52aa 0056      	addql #1,%a2@(86)                                 	<== NOT EXECUTED
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   4683c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4683e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46840:	4eb9 0004 8220 	jsr 48220 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

  _Thread_Enable_dispatch();
}
   46846:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4684a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );

  _Thread_Enable_dispatch();
   4684e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   46854:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );

  _Thread_Enable_dispatch();
   46856:	4ef9 0004 7cbc 	jmp 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
{
  Thread_Control   *executing;

  executing = _Thread_Executing;
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {
    if ( the_mutex->holder->current_priority > executing->current_priority ) {
   4685c:	2028 0014      	movel %a0@(20),%d0                                	<== NOT EXECUTED
   46860:	206a 005a      	moveal %a2@(90),%a0                               	<== NOT EXECUTED
   46864:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   46868:	64c8           	bccs 46832 <_CORE_mutex_Seize_interrupt_blocking+0x1e>	<== NOT EXECUTED
      _Thread_Change_priority(
   4686a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4686c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4686e:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46870:	4eb9 0004 7794 	jsr 47794 <_Thread_Change_priority>               	<== NOT EXECUTED
   46876:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
      );
    }
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   4687c:	4879 0004 85e0 	pea 485e0 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
        FALSE
      );
    }
  }

  the_mutex->blocked_count++;
   46882:	52aa 0056      	addql #1,%a2@(86)                                 	<== NOT EXECUTED
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   46886:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46888:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4688a:	4eb9 0004 8220 	jsr 48220 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

  _Thread_Enable_dispatch();
}
   46890:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46894:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );

  _Thread_Enable_dispatch();
   46898:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   4689e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );

  _Thread_Enable_dispatch();
   468a0:	4ef9 0004 7cbc 	jmp 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED

0004b294 <_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
)
{
   4b294:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b298:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   4b29c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  CORE_mutex_Control  *the_mutex,
  ISR_Level           *level_p
)
{
  Thread_Control   *executing;
  ISR_Level         level = *level_p;
   4b29e:	2410           	movel %a0@,%d2                                    	<== NOT EXECUTED

  /* disabled when you get here */

  executing = _Thread_Executing;
   4b2a0:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4b2a6:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
   4b2aa:	42a8 0034      	clrl %a0@(52)                                     	<== NOT EXECUTED
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
   4b2ae:	4aa9 004e      	tstl %a1@(78)                                     	<== NOT EXECUTED
   4b2b2:	6734           	beqs 4b2e8 <_CORE_mutex_Seize_interrupt_trylock+0x54>	<== NOT EXECUTED
    the_mutex->lock       = CORE_MUTEX_LOCKED;
   4b2b4:	42a9 004e      	clrl %a1@(78)                                     	<== NOT EXECUTED
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
   4b2b8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
    the_mutex->lock       = CORE_MUTEX_LOCKED;
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
   4b2ba:	2368 0008 005e 	movel %a0@(8),%a1@(94)                            	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
  CORE_mutex_Attributes *the_attribute
)
{
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
   4b2c0:	2029 0046      	movel %a1@(70),%d0                                	<== NOT EXECUTED
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
    the_mutex->lock       = CORE_MUTEX_LOCKED;
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
   4b2c4:	2341 0052      	movel %d1,%a1@(82)                                	<== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4b2c8:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
    the_mutex->lock       = CORE_MUTEX_LOCKED;
    the_mutex->holder     = executing;
   4b2cc:	2348 005a      	movel %a0,%a1@(90)                                	<== NOT EXECUTED
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4b2d0:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b2d2:	6724           	beqs 4b2f8 <_CORE_mutex_Seize_interrupt_trylock+0x64>	<== NOT EXECUTED
   4b2d4:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   4b2d8:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b2da:	671c           	beqs 4b2f8 <_CORE_mutex_Seize_interrupt_trylock+0x64>	<== NOT EXECUTED

      executing->resource_count++;
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
        _ISR_Enable( level );
   4b2dc:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
   4b2de:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b2e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b2e4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b2e6:	4e75           	rts                                               	<== NOT EXECUTED
  /*
   *  At this point, we know the mutex was not available.  If this thread
   *  is the thread that has locked the mutex, let's see if we are allowed
   *  to nest access.
   */
  if ( _Thread_Is_executing( the_mutex->holder ) ) {
   4b2e8:	b1e9 005a      	cmpal %a1@(90),%a0                                	<== NOT EXECUTED
   4b2ec:	6744           	beqs 4b332 <_CORE_mutex_Seize_interrupt_trylock+0x9e>	<== NOT EXECUTED
   4b2ee:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b2f2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        the_mutex->nest_count++;
        _ISR_Enable( level );
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
        _ISR_Enable( level );
   4b2f4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4b2f6:	4e75           	rts                                               	<== NOT EXECUTED
       _Chain_Prepend_unprotected( &executing->lock_mutex,
                                   &the_mutex->queue.lock_queue );
       the_mutex->queue.priority_before = executing->current_priority;
#endif

      executing->resource_count++;
   4b2f8:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
   4b2fc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4b2fe:	b0a9 0046      	cmpl %a1@(70),%d0                                 	<== NOT EXECUTED
   4b302:	66d8           	bnes 4b2dc <_CORE_mutex_Seize_interrupt_trylock+0x48>	<== NOT EXECUTED
       */
    {
      Priority_Control  ceiling;
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
   4b304:	2229 004a      	movel %a1@(74),%d1                                	<== NOT EXECUTED
      current = executing->current_priority;
   4b308:	2028 0014      	movel %a0@(20),%d0                                	<== NOT EXECUTED
      if ( current == ceiling ) {
   4b30c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4b30e:	6750           	beqs 4b360 <_CORE_mutex_Seize_interrupt_trylock+0xcc>	<== NOT EXECUTED
        _ISR_Enable( level );
        return 0;
      }

      if ( current > ceiling ) {
   4b310:	625a           	bhis 4b36c <_CORE_mutex_Seize_interrupt_trylock+0xd8>	<== NOT EXECUTED
        );
        _Thread_Enable_dispatch();
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
   4b312:	7206           	moveq #6,%d1                                      	<== NOT EXECUTED
   4b314:	2141 0034      	movel %d1,%a0@(52)                                	<== NOT EXECUTED
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
   4b318:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        the_mutex->nest_count = 0;     /* undo locking above */
   4b31a:	42a9 0052      	clrl %a1@(82)                                     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
   4b31e:	2340 004e      	movel %d0,%a1@(78)                                	<== NOT EXECUTED
        the_mutex->nest_count = 0;     /* undo locking above */
        executing->resource_count--;   /* undo locking above */
   4b322:	53a8 001c      	subql #1,%a0@(28)                                 	<== NOT EXECUTED
        _ISR_Enable( level );
   4b326:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   4b328:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b32c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b32e:	4200           	clrb %d0                                          	<== NOT EXECUTED
   4b330:	4e75           	rts                                               	<== NOT EXECUTED
   *  At this point, we know the mutex was not available.  If this thread
   *  is the thread that has locked the mutex, let's see if we are allowed
   *  to nest access.
   */
  if ( _Thread_Is_executing( the_mutex->holder ) ) {
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   4b332:	2029 0040      	movel %a1@(64),%d0                                	<== NOT EXECUTED
   4b336:	6718           	beqs 4b350 <_CORE_mutex_Seize_interrupt_trylock+0xbc>	<== NOT EXECUTED
   4b338:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4b33a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b33c:	66b0           	bnes 4b2ee <_CORE_mutex_Seize_interrupt_trylock+0x5a>	<== NOT EXECUTED
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
        _ISR_Enable( level );
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
   4b33e:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4b340:	2140 0034      	movel %d0,%a0@(52)                                	<== NOT EXECUTED
        _ISR_Enable( level );
   4b344:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   4b346:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b34a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b34c:	4200           	clrb %d0                                          	<== NOT EXECUTED
   4b34e:	4e75           	rts                                               	<== NOT EXECUTED
   *  to nest access.
   */
  if ( _Thread_Is_executing( the_mutex->holder ) ) {
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
   4b350:	52a9 0052      	addql #1,%a1@(82)                                 	<== NOT EXECUTED
        _ISR_Enable( level );
   4b354:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   4b356:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b35a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b35c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b35e:	4e75           	rts                                               	<== NOT EXECUTED
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
      current = executing->current_priority;
      if ( current == ceiling ) {
        _ISR_Enable( level );
   4b360:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   4b362:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b366:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b368:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b36a:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4b36c:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4b372:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4b374:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
        return 0;
      }

      if ( current > ceiling ) {
        _Thread_Disable_dispatch();
        _ISR_Enable( level );
   4b37a:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
        _Thread_Change_priority(
   4b37c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4b37e:	2f29 004a      	movel %a1@(74),%sp@-                              	<== NOT EXECUTED
   4b382:	2f29 005a      	movel %a1@(90),%sp@-                              	<== NOT EXECUTED
   4b386:	4eb9 0004 7794 	jsr 47794 <_Thread_Change_priority>               	<== NOT EXECUTED
          the_mutex->holder,
          the_mutex->Attributes.priority_ceiling,
         FALSE
        );
        _Thread_Enable_dispatch();
   4b38c:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4b392:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b396:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4b39c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b39e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b3a0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046958 <_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
)
{
   46958:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4695c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4695e:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  Thread_Control *the_thread;
  Thread_Control *holder;
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
  Chain_Node *first_node;
#endif
  holder    = the_mutex->holder;
   46962:	206a 005a      	moveal %a2@(90),%a0                               	<== 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 ) {
   46966:	4a2a 0044      	tstb %a2@(68)                                     	<== NOT EXECUTED
   4696a:	6712           	beqs 4697e <_CORE_mutex_Surrender+0x26>           	<== NOT EXECUTED
    if ( !_Thread_Is_executing( holder ) )
   4696c:	b1f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a0               	<== NOT EXECUTED
   46972:	670a           	beqs 4697e <_CORE_mutex_Surrender+0x26>           	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46974:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46978:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *  discipline.  But Priority Ceiling or Priority Inheritance mutexes
   *  must be released by the thread which acquired them.
   */

  if ( the_mutex->Attributes.only_owner_release ) {
    if ( !_Thread_Is_executing( holder ) )
   4697a:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   4697c:	4e75           	rts                                               	<== NOT EXECUTED
      return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
  }

  /* XXX already unlocked -- not right status */

  if ( !the_mutex->nest_count )
   4697e:	202a 0052      	movel %a2@(82),%d0                                	<== NOT EXECUTED
   46982:	6776           	beqs 469fa <_CORE_mutex_Surrender+0xa2>           	<== NOT EXECUTED
    return CORE_MUTEX_STATUS_SUCCESSFUL;

  the_mutex->nest_count--;
   46984:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46986:	2540 0052      	movel %d0,%a2@(82)                                	<== NOT EXECUTED

  if ( the_mutex->nest_count != 0 ) {
   4698a:	670e           	beqs 4699a <_CORE_mutex_Surrender+0x42>           	<== NOT EXECUTED
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   4698c:	202a 0040      	movel %a2@(64),%d0                                	<== NOT EXECUTED
   46990:	6768           	beqs 469fa <_CORE_mutex_Surrender+0xa2>           	<== NOT EXECUTED
   46992:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46994:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46996:	6700 00c4      	beqw 46a5c <_CORE_mutex_Surrender+0x104>          	<== NOT EXECUTED
   4699a:	202a 0046      	movel %a2@(70),%d0                                	<== NOT EXECUTED

  /*
   *  Formally release the mutex before possibly transferring it to a
   *  blocked thread.
   */
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4699e:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   469a0:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469a2:	6700 0086      	beqw 46a2a <_CORE_mutex_Surrender+0xd2>           	<== NOT EXECUTED
   469a6:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   469aa:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469ac:	677c           	beqs 46a2a <_CORE_mutex_Surrender+0xd2>           	<== NOT EXECUTED
    }
    first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
    holder->resource_count--;
  }
  the_mutex->holder    = NULL;
   469ae:	42aa 005a      	clrl %a2@(90)                                     	<== 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 ) ||
   469b2:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
    first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
    holder->resource_count--;
  }
  the_mutex->holder    = NULL;
  the_mutex->holder_id = 0;
   469b4:	42aa 005e      	clrl %a2@(94)                                     	<== 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 ) ||
   469b8:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469ba:	6748           	beqs 46a04 <_CORE_mutex_Surrender+0xac>           	<== NOT EXECUTED
   469bc:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   469c0:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469c2:	6740           	beqs 46a04 <_CORE_mutex_Surrender+0xac>           	<== 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 ) ) ) {
   469c4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   469c6:	4eb9 0004 80b8 	jsr 480b8 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
   469cc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   469ce:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   469d0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   469d2:	6700 00a0      	beqw 46a74 <_CORE_mutex_Surrender+0x11c>          	<== NOT EXECUTED
#endif
    {

      the_mutex->holder     = the_thread;
      the_mutex->holder_id  = the_thread->Object.id;
      the_mutex->nest_count = 1;
   469d6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
    } else
#endif
    {

      the_mutex->holder     = the_thread;
      the_mutex->holder_id  = the_thread->Object.id;
   469d8:	2568 0008 005e 	movel %a0@(8),%a2@(94)                            	<== NOT EXECUTED
      the_mutex->nest_count = 1;

      switch ( the_mutex->Attributes.discipline ) {
   469de:	202a 0046      	movel %a2@(70),%d0                                	<== NOT EXECUTED
#endif
    {

      the_mutex->holder     = the_thread;
      the_mutex->holder_id  = the_thread->Object.id;
      the_mutex->nest_count = 1;
   469e2:	2541 0052      	movel %d1,%a2@(82)                                	<== NOT EXECUTED

      switch ( the_mutex->Attributes.discipline ) {
   469e6:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED

    } else
#endif
    {

      the_mutex->holder     = the_thread;
   469ea:	2548 005a      	movel %a0,%a2@(90)                                	<== NOT EXECUTED
      the_mutex->holder_id  = the_thread->Object.id;
      the_mutex->nest_count = 1;

      switch ( the_mutex->Attributes.discipline ) {
   469ee:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469f0:	6774           	beqs 46a66 <_CORE_mutex_Surrender+0x10e>          	<== NOT EXECUTED
   469f2:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   469f6:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   469f8:	6738           	beqs 46a32 <_CORE_mutex_Surrender+0xda>           	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   469fa:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   469fe:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          }
          break;
      }
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;
   46a00:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a02:	4e75           	rts                                               	<== 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 &&
   46a04:	4aa8 001c      	tstl %a0@(28)                                     	<== NOT EXECUTED
   46a08:	66ba           	bnes 469c4 <_CORE_mutex_Surrender+0x6c>           	<== NOT EXECUTED
   46a0a:	2028 0018      	movel %a0@(24),%d0                                	<== NOT EXECUTED
   46a0e:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   46a12:	67b0           	beqs 469c4 <_CORE_mutex_Surrender+0x6c>           	<== NOT EXECUTED
         holder->real_priority != holder->current_priority ) {
      _Thread_Change_priority( holder, holder->real_priority, TRUE );
   46a14:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46a18:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46a1a:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46a1c:	4eb9 0004 7794 	jsr 47794 <_Thread_Change_priority>               	<== NOT EXECUTED
   46a22:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46a28:	609a           	bras 469c4 <_CORE_mutex_Surrender+0x6c>           	<== 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--;
   46a2a:	53a8 001c      	subql #1,%a0@(28)                                 	<== NOT EXECUTED
   46a2e:	6000 ff7e      	braw 469ae <_CORE_mutex_Surrender+0x56>           	<== 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++;
   46a32:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
          if (the_mutex->Attributes.priority_ceiling <
   46a36:	202a 004a      	movel %a2@(74),%d0                                	<== NOT EXECUTED
   46a3a:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   46a3e:	64ba           	bccs 469fa <_CORE_mutex_Surrender+0xa2>           	<== NOT EXECUTED
              the_thread->current_priority){
              _Thread_Change_priority(
   46a40:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a42:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46a44:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46a46:	4eb9 0004 7794 	jsr 47794 <_Thread_Change_priority>               	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a4c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
	  the_mutex->queue.priority_before = the_thread->current_priority;
#endif
          the_thread->resource_count++;
          if (the_mutex->Attributes.priority_ceiling <
              the_thread->current_priority){
              _Thread_Change_priority(
   46a50:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
	  the_mutex->queue.priority_before = the_thread->current_priority;
#endif
          the_thread->resource_count++;
          if (the_mutex->Attributes.priority_ceiling <
              the_thread->current_priority){
              _Thread_Change_priority(
   46a58:	4280           	clrl %d0                                          	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a5a:	4e75           	rts                                               	<== NOT EXECUTED
   46a5c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46a60:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return CORE_MUTEX_STATUS_SUCCESSFUL;

  the_mutex->nest_count--;

  if ( the_mutex->nest_count != 0 ) {
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   46a62:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a64:	4e75           	rts                                               	<== NOT EXECUTED
   46a66:	246e fffc      	moveal %fp@(-4),%a2                               	<== 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++;
   46a6a:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a6e:	4e5e           	unlk %fp                                          	<== 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++;
   46a70:	4280           	clrl %d0                                          	<== NOT EXECUTED
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a72:	4e75           	rts                                               	<== NOT EXECUTED
          }
          break;
      }
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;
   46a74:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46a76:	2540 004e      	movel %d0,%a2@(78)                                	<== NOT EXECUTED

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a7a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46a7e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          }
          break;
      }
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;
   46a80:	4200           	clrb %d0                                          	<== NOT EXECUTED

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   46a82:	4e75           	rts

00046a84 <_CORE_semaphore_Flush>:
void _CORE_semaphore_Flush(
  CORE_semaphore_Control     *the_semaphore,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   46a84:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
    &the_semaphore->Wait_queue,
    remote_extract_callout,
    status
  );

}
   46a88:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{

  _Thread_queue_Flush(
   46a8a:	4ef9 0004 84a0 	jmp 484a0 <_Thread_queue_Flush>                   	<== NOT EXECUTED

00046a90 <_CORE_semaphore_Initialize>:
void _CORE_semaphore_Initialize(
  CORE_semaphore_Control       *the_semaphore,
  CORE_semaphore_Attributes    *the_semaphore_attributes,
  uint32_t                      initial_value
)
{
   46a90:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED

  the_semaphore->Attributes = *the_semaphore_attributes;
  the_semaphore->count      = initial_value;

  _Thread_queue_Initialize(
   46a94:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED
void _CORE_semaphore_Initialize(
  CORE_semaphore_Control       *the_semaphore,
  CORE_semaphore_Attributes    *the_semaphore_attributes,
  uint32_t                      initial_value
)
{
   46a98:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   46a9c:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED

  the_semaphore->Attributes = *the_semaphore_attributes;
   46aa0:	2368 0004 0044 	movel %a0@(4),%a1@(68)                            	<== NOT EXECUTED
  the_semaphore->count      = initial_value;

  _Thread_queue_Initialize(
   46aa6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46aa8:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   46aac:	57c0           	seq %d0                                           	<== NOT EXECUTED
  CORE_semaphore_Attributes    *the_semaphore_attributes,
  uint32_t                      initial_value
)
{

  the_semaphore->Attributes = *the_semaphore_attributes;
   46aae:	2210           	movel %a0@,%d1                                    	<== NOT EXECUTED
  the_semaphore->count      = initial_value;

  _Thread_queue_Initialize(
   46ab0:	4878 0200      	pea 200 <FP_REGS_SAVED+0x1c0>                     	<== NOT EXECUTED
   46ab4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   46ab6:	4480           	negl %d0                                          	<== NOT EXECUTED
   46ab8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
  uint32_t                      initial_value
)
{

  the_semaphore->Attributes = *the_semaphore_attributes;
  the_semaphore->count      = initial_value;
   46aba:	236e 0010 0048 	movel %fp@(16),%a1@(72)                           	<== NOT EXECUTED
  CORE_semaphore_Attributes    *the_semaphore_attributes,
  uint32_t                      initial_value
)
{

  the_semaphore->Attributes = *the_semaphore_attributes;
   46ac0:	2341 0040      	movel %d1,%a1@(64)                                	<== NOT EXECUTED
  the_semaphore->count      = initial_value;

  _Thread_queue_Initialize(
   46ac4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   46ac6:	4eb9 0004 84dc 	jsr 484dc <_Thread_queue_Initialize>              	<== NOT EXECUTED
   46acc:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    _CORE_semaphore_Is_priority( the_semaphore_attributes ) ?
              THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_SEMAPHORE,
    CORE_SEMAPHORE_TIMEOUT
  );
}
   46ad2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46ad4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046ad8 <_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
)
{
   46ad8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46adc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46ade:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   46ae2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level       level;
  CORE_semaphore_Status status;

  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;

  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
   46ae4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46ae6:	4eb9 0004 80b8 	jsr 480b8 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
   46aec:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46aee:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46af0:	670e           	beqs 46b00 <_CORE_semaphore_Surrender+0x28>       	<== NOT EXECUTED
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
  }

  return status;
}
   46af2:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46af6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46afa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  ISR_Level       level;
  CORE_semaphore_Status status;

  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;

  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
   46afc:	4280           	clrl %d0                                          	<== NOT EXECUTED
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
  }

  return status;
}
   46afe:	4e75           	rts                                               	<== NOT EXECUTED
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_semaphore_mp_support) ( the_thread, id );
#endif

  } else {
    _ISR_Disable( level );
   46b00:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46b06:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46b08:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46b0a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
   46b0c:	222a 0048      	movel %a2@(72),%d1                                	<== NOT EXECUTED
   46b10:	b2aa 0040      	cmpl %a2@(64),%d1                                 	<== NOT EXECUTED
   46b14:	6510           	bcss 46b26 <_CORE_semaphore_Surrender+0x4e>       	<== NOT EXECUTED
   46b16:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
        the_semaphore->count += 1;
      else
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
   46b18:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  }

  return status;
}
   46b1a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46b1e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46b22:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46b24:	4e75           	rts                                               	<== NOT EXECUTED
#endif

  } else {
    _ISR_Disable( level );
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;
   46b26:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   46b28:	2541 0048      	movel %d1,%a2@(72)                                	<== NOT EXECUTED
   46b2c:	4280           	clrl %d0                                          	<== NOT EXECUTED
      else
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
   46b2e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   46b30:	60e8           	bras 46b1a <_CORE_semaphore_Surrender+0x42>       	<== NOT EXECUTED
	...

000466d8 <_Chain_Append>:

void _Chain_Append(
  Chain_Control *the_chain,
  Chain_Node    *node
)
{
   466d8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   466dc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   466de:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED

void _Chain_Append(
  Chain_Control *the_chain,
  Chain_Node    *node
)
{
   466e4:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   466e8:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   466ec:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   466ee:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   466f0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   466f2:	2209           	movel %a1,%d1                                     	<== NOT EXECUTED
   466f4:	5881           	addql #4,%d1                                      	<== NOT EXECUTED
   466f6:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   466f8:	2469 0008      	moveal %a1@(8),%a2                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   466fc:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   46700:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   46704:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
    _Chain_Append_unprotected( the_chain, node );
  _ISR_Enable( level );
   46706:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   46708:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4670a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4670c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b1cc <_Chain_Extract>:
 */

void _Chain_Extract(
  Chain_Node *node
)
{
   4b1cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b1d0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4b1d2:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
 */

void _Chain_Extract(
  Chain_Node *node
)
{
   4b1d8:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4b1dc:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4b1de:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4b1e0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
   4b1e2:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   4b1e6:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
   4b1e8:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4b1ea:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
    _Chain_Extract_unprotected( node );
  _ISR_Enable( level );
   4b1ee:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   4b1f0:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4b1f2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b1f4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b1f8 <_Chain_Get>:
 */

Chain_Node *_Chain_Get(
  Chain_Control *the_chain
)
{
   4b1f8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b1fc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level          level;
  Chain_Node *return_node;

  return_node = NULL;
  _ISR_Disable( level );
   4b1fe:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Chain_Node *_Chain_Get(
  Chain_Control *the_chain
)
{
   4b204:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level          level;
  Chain_Node *return_node;

  return_node = NULL;
  _ISR_Disable( level );
   4b208:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4b20a:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4b20c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   4b20e:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   4b210:	2258           	moveal %a0@+,%a1                                  	<== NOT EXECUTED
    if ( !_Chain_Is_empty( the_chain ) )
   4b212:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   4b214:	6712           	beqs 4b228 <_Chain_Get+0x30>                      	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   4b216:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   4b218:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   4b21a:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
      return_node = _Chain_Get_first_unprotected( the_chain );
  _ISR_Enable( level );
   4b21e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  return return_node;
}
   4b220:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4b222:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b224:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   4b226:	4e75           	rts                                               	<== NOT EXECUTED
  ISR_Level          level;
  Chain_Node *return_node;

  return_node = NULL;
  _ISR_Disable( level );
    if ( !_Chain_Is_empty( the_chain ) )
   4b228:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
      return_node = _Chain_Get_first_unprotected( the_chain );
  _ISR_Enable( level );
   4b22a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  return return_node;
}
   4b22c:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4b22e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b230:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   4b232:	4e75           	rts

0004b234 <_Chain_Initialize>:
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   4b234:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4b238:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   4b23c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4b240:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4b244:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   4b248:	222e 0014      	movel %fp@(20),%d1                                	<== NOT EXECUTED
  Chain_Node *current;
  Chain_Node *next;

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
   4b24c:	42aa 0004      	clrl %a2@(4)                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
   4b250:	224a           	moveal %a2,%a1                                    	<== NOT EXECUTED
  next                      = starting_address;
  while ( count-- ) {
   4b252:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b254:	672c           	beqs 4b282 <_Chain_Initialize+0x4e>               	<== NOT EXECUTED
   4b256:	2043           	moveal %d3,%a0                                    	<== NOT EXECUTED
    current->next  = next;
    next->previous = current;
   4b258:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
  next                      = starting_address;
  while ( count-- ) {
   4b25c:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4b25e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
    current->next  = next;
   4b260:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   4b262:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   4b264:	d1c1           	addal %d1,%a0                                     	<== NOT EXECUTED

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
  next                      = starting_address;
  while ( count-- ) {
   4b266:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b268:	6710           	beqs 4b27a <_Chain_Initialize+0x46>               	<== NOT EXECUTED
    current->next  = next;
    next->previous = current;
   4b26a:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
   4b26e:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
  next                      = starting_address;
  while ( count-- ) {
    current->next  = next;
   4b270:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   4b272:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   4b274:	d1c1           	addal %d1,%a0                                     	<== NOT EXECUTED

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
  next                      = starting_address;
  while ( count-- ) {
   4b276:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b278:	66f0           	bnes 4b26a <_Chain_Initialize+0x36>               	<== NOT EXECUTED
   4b27a:	4c02 1800      	mulsl %d2,%d1                                     	<== NOT EXECUTED
   4b27e:	2243           	moveal %d3,%a1                                    	<== NOT EXECUTED
   4b280:	d3c1           	addal %d1,%a1                                     	<== NOT EXECUTED
    next->previous = current;
    current        = next;
    next           = (Chain_Node *)
                        _Addresses_Add_offset( (void *) next, node_size );
  }
  current->next    = _Chain_Tail( the_chain );
   4b282:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4b284:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4b286:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last  = current;
   4b288:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
}
   4b28c:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   4b290:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b292:	4e75           	rts

000631dc <_Chain_Insert>:

void _Chain_Insert(
  Chain_Node *after_node,
  Chain_Node *node
)
{
   631dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   631e0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   631e2:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED

void _Chain_Insert(
  Chain_Node *after_node,
  Chain_Node *node
)
{
   631e8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   631ec:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   631f0:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   631f2:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   631f4:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   631f6:	2451           	moveal %a1@,%a2                                   	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   631f8:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
   631fc:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  the_node->next        = before_node;
  before_node->previous = the_node;
   631fe:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
   63202:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
    _Chain_Insert_unprotected( after_node, node );
  _ISR_Enable( level );
   63204:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   63206:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   63208:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   6320a:	4e75           	rts

0004b160 <_Debug_Is_enabled>:
 */

bool _Debug_Is_enabled(
  rtems_debug_control  level
)
{
   4b160:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b164:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4b168:	c0b9 0005 8816 	andl 58816 <_Debug_Level>,%d0                     	<== NOT EXECUTED
   4b16e:	56c0           	sne %d0                                           	<== NOT EXECUTED
  return (_Debug_Level & level) ? true : false;
}
   4b170:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b172:	4480           	negl %d0                                          	<== NOT EXECUTED
   4b174:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b12c <_Debug_Manager_initialization>:
 *
 *  _Debug_Manager_initialization
 */

void _Debug_Manager_initialization( void )
{
   4b12c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  rtems_debug_disable( RTEMS_DEBUG_ALL_MASK );
}
   4b130:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
  _Debug_Level &= ~to_be_disabled;
   4b132:	42b9 0005 8816 	clrl 58816 <_Debug_Level>                         	<== NOT EXECUTED
 */

void _Debug_Manager_initialization( void )
{
  rtems_debug_disable( RTEMS_DEBUG_ALL_MASK );
}
   4b138:	4e75           	rts

0004ad4c <_Dual_ported_memory_Manager_initialization>:
 */

void _Dual_ported_memory_Manager_initialization(
  uint32_t   maximum_ports
)
{
   4ad4c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ad50:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ad54:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ad56:	4878 001c      	pea 1c <OPER2+0x8>                                	<== NOT EXECUTED
   4ad5a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ad5e:	4878 0007      	pea 7 <TRUNCDFSF>                                 	<== NOT EXECUTED
   4ad62:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ad66:	4879 0005 8a12 	pea 58a12 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4ad6c:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4ad72:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                        /* TRUE if this is a global object class */
    NULL                          /* Proxy extraction support callout */
#endif
  );
}
   4ad78:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ad7a:	4e75           	rts

0004ad7c <_Event_Manager_initialization>:
 *
 *  This routine performs the initialization necessary for this manager.
 */

void _Event_Manager_initialization( void )
{
   4ad7c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   */

#if defined(RTEMS_MULTIPROCESSING)
  _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet );
#endif
}
   4ad80:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
 *  This routine performs the initialization necessary for this manager.
 */

void _Event_Manager_initialization( void )
{
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   4ad82:	42b9 0005 898e 	clrl 5898e <_Event_Sync_state>                    	<== NOT EXECUTED
   */

#if defined(RTEMS_MULTIPROCESSING)
  _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet );
#endif
}
   4ad88:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004555c <_Event_Seize>:
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   4555c:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   45560:	48d7 047c      	moveml %d2-%d6/%a2,%sp@                           	<== NOT EXECUTED
  rtems_event_set                   pending_events;
  ISR_Level                         level;
  RTEMS_API_Control                *api;
  Thread_blocking_operation_States  sync_state;

  executing = _Thread_Executing;
   45564:	2479 0005 8812 	moveal 58812 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   4556a:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4556e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   45572:	2c2e 0010      	movel %fp@(16),%d6                                	<== NOT EXECUTED
  executing = _Thread_Executing;
  executing->Wait.return_code = RTEMS_SUCCESSFUL;

  api = executing->API_Extensions[ THREAD_API_RTEMS ];

  _ISR_Disable( level );
   45576:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
  ISR_Level                         level;
  RTEMS_API_Control                *api;
  Thread_blocking_operation_States  sync_state;

  executing = _Thread_Executing;
  executing->Wait.return_code = RTEMS_SUCCESSFUL;
   4557c:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   45580:	226e 0014      	moveal %fp@(20),%a1                               	<== NOT EXECUTED
  Thread_blocking_operation_States  sync_state;

  executing = _Thread_Executing;
  executing->Wait.return_code = RTEMS_SUCCESSFUL;

  api = executing->API_Extensions[ THREAD_API_RTEMS ];
   45584:	206a 010c      	moveal %a2@(268),%a0                              	<== NOT EXECUTED

  _ISR_Disable( level );
   45588:	40c5           	movew %sr,%d5                                     	<== NOT EXECUTED
   4558a:	8085           	orl %d5,%d0                                       	<== NOT EXECUTED
   4558c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  pending_events = api->pending_events;
   4558e:	2810           	movel %a0@,%d4                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
  rtems_event_set the_event_set,
  rtems_event_set the_event_condition
)
{
   return ( the_event_set & the_event_condition );
   45590:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   45592:	c284           	andl %d4,%d1                                      	<== NOT EXECUTED
  seized_events  = _Event_sets_Get( pending_events, event_in );

  if ( !_Event_sets_Is_empty( seized_events ) &&
   45594:	670c           	beqs 455a2 <_Event_Seize+0x46>                    	<== NOT EXECUTED
   45596:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   45598:	6700 0084      	beqw 4561e <_Event_Seize+0xc2>                    	<== NOT EXECUTED
   4559c:	0803 0001      	btst #1,%d3                                       	<== NOT EXECUTED
   455a0:	667c           	bnes 4561e <_Event_Seize+0xc2>                    	<== NOT EXECUTED
    _ISR_Enable( level );
    *event_out = seized_events;
    return;
  }

  if ( _Options_Is_no_wait( option_set ) ) {
   455a2:	0803 0000      	btst #0,%d3                                       	<== NOT EXECUTED
   455a6:	6662           	bnes 4560a <_Event_Seize+0xae>                    	<== NOT EXECUTED
    executing->Wait.return_code = RTEMS_UNSATISFIED;
    *event_out = seized_events;
    return;
  }

  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   455a8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED

  executing->Wait.option            = (uint32_t) option_set;
   455aa:	2543 0030      	movel %d3,%a2@(48)                                	<== NOT EXECUTED
    executing->Wait.return_code = RTEMS_UNSATISFIED;
    *event_out = seized_events;
    return;
  }

  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   455ae:	23c1 0005 898e 	movel %d1,5898e <_Event_Sync_state>               	<== NOT EXECUTED

  executing->Wait.option            = (uint32_t) option_set;
  executing->Wait.count             = (uint32_t) event_in;
   455b4:	2542 0024      	movel %d2,%a2@(36)                                	<== NOT EXECUTED
  executing->Wait.return_argument   = event_out;
   455b8:	2549 0028      	movel %a1,%a2@(40)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   455bc:	46c5           	movew %d5,%sr                                     	<== NOT EXECUTED

  if ( ticks ) {
   455be:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   455c0:	6672           	bnes 45634 <_Event_Seize+0xd8>                    	<== NOT EXECUTED
      NULL
    );
    _Watchdog_Insert_ticks( &executing->Timer, ticks );
  }

  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
   455c2:	4878 0100      	pea 100 <FP_REGS_SAVED+0xc0>                      	<== NOT EXECUTED
   455c6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   455c8:	4eb9 0004 8680 	jsr 48680 <_Thread_Set_state>                     	<== NOT EXECUTED

  _ISR_Disable( level );
   455ce:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   455d4:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   455d6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   455d8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  sync_state = _Event_Sync_state;
   455da:	2039 0005 898e 	movel 5898e <_Event_Sync_state>,%d0               	<== NOT EXECUTED
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   455e0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );

  _ISR_Disable( level );

  sync_state = _Event_Sync_state;
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   455e2:	42b9 0005 898e 	clrl 5898e <_Event_Sync_state>                    	<== NOT EXECUTED
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   455e8:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   455ea:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   455ec:	6700 00a4      	beqw 45692 <_Event_Seize+0x136>                   	<== 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 );
   455f0:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
}
   455f4:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== 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 );
   455fa:	2d41 0010      	movel %d1,%fp@(16)                                	<== NOT EXECUTED
   455fe:	2d40 0008      	movel %d0,%fp@(8)                                 	<== NOT EXECUTED
}
   45602:	4e5e           	unlk %fp                                          	<== 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 );
   45604:	4ef9 0004 772c 	jmp 4772c <_Thread_blocking_operation_Cancel>     	<== NOT EXECUTED
    *event_out = seized_events;
    return;
  }

  if ( _Options_Is_no_wait( option_set ) ) {
    _ISR_Enable( level );
   4560a:	46c5           	movew %d5,%sr                                     	<== NOT EXECUTED
    executing->Wait.return_code = RTEMS_UNSATISFIED;
   4560c:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   4560e:	2540 0034      	movel %d0,%a2@(52)                                	<== NOT EXECUTED
   *  The blocking thread was satisfied by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  _Thread_blocking_operation_Cancel( sync_state, executing, level );
}
   45612:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   45618:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  if ( _Options_Is_no_wait( option_set ) ) {
    _ISR_Enable( level );
    executing->Wait.return_code = RTEMS_UNSATISFIED;
    *event_out = seized_events;
   4561a:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
   *  The blocking thread was satisfied by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  _Thread_blocking_operation_Cancel( sync_state, executing, level );
}
   4561c:	4e75           	rts                                               	<== NOT EXECUTED
  pending_events = api->pending_events;
  seized_events  = _Event_sets_Get( pending_events, event_in );

  if ( !_Event_sets_Is_empty( seized_events ) &&
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
    api->pending_events =
   4561e:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   45620:	4680           	notl %d0                                          	<== NOT EXECUTED
   45622:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   45624:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
      _Event_sets_Clear( pending_events, seized_events );
    _ISR_Enable( level );
   45626:	46c5           	movew %d5,%sr                                     	<== NOT EXECUTED
   *  The blocking thread was satisfied by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  _Thread_blocking_operation_Cancel( sync_state, executing, level );
}
   45628:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   4562e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  if ( !_Event_sets_Is_empty( seized_events ) &&
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
    api->pending_events =
      _Event_sets_Clear( pending_events, seized_events );
    _ISR_Enable( level );
    *event_out = seized_events;
   45630:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
   *  The blocking thread was satisfied by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  _Thread_blocking_operation_Cancel( sync_state, executing, level );
}
   45632:	4e75           	rts                                               	<== NOT EXECUTED
  executing->Wait.return_argument   = event_out;

  _ISR_Enable( level );

  if ( ticks ) {
    _Watchdog_Initialize(
   45634:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45638:	243c 0004 581c 	movel #284700,%d2                                 	<== NOT EXECUTED
  the_watchdog->id        = id;
   4563e:	2540 0068      	movel %d0,%a2@(104)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45642:	2546 0054      	movel %d6,%a2@(84)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45646:	2542 0064      	movel %d2,%a2@(100)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4564a:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   4564e:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   45652:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   45656:	4879 0005 8830 	pea 58830 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   4565c:	4eb9 0004 8ed4 	jsr 48ed4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   45662:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      NULL
    );
    _Watchdog_Insert_ticks( &executing->Timer, ticks );
  }

  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
   45664:	4878 0100      	pea 100 <FP_REGS_SAVED+0xc0>                      	<== NOT EXECUTED
   45668:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4566a:	4eb9 0004 8680 	jsr 48680 <_Thread_Set_state>                     	<== NOT EXECUTED

  _ISR_Disable( level );
   45670:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   45676:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   45678:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4567a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  sync_state = _Event_Sync_state;
   4567c:	2039 0005 898e 	movel 5898e <_Event_Sync_state>,%d0               	<== NOT EXECUTED
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   45682:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );

  _ISR_Disable( level );

  sync_state = _Event_Sync_state;
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   45684:	42b9 0005 898e 	clrl 5898e <_Event_Sync_state>                    	<== NOT EXECUTED
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   4568a:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4568c:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   4568e:	6600 ff60      	bnew 455f0 <_Event_Seize+0x94>                    	<== NOT EXECUTED
    _ISR_Enable( level );
   45692:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   *  The blocking thread was satisfied by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  _Thread_blocking_operation_Cancel( sync_state, executing, level );
}
   45694:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   4569a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4569c:	4e75           	rts                                               	<== NOT EXECUTED
	...

000456f0 <_Event_Surrender>:
 */

void _Event_Surrender(
  Thread_Control *the_thread
)
{
   456f0:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   456f4:	48d7 047c      	moveml %d2-%d6/%a2,%sp@                           	<== NOT EXECUTED
   456f8:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED

  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];

  option_set = (rtems_option) the_thread->Wait.option;

  _ISR_Disable( level );
   456fc:	203c 0000 0700 	movel #1792,%d0                                   	<== 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 ];
   45702:	206a 010c      	moveal %a2@(268),%a0                              	<== NOT EXECUTED

  option_set = (rtems_option) the_thread->Wait.option;
   45706:	2a2a 0030      	movel %a2@(48),%d5                                	<== NOT EXECUTED

  _ISR_Disable( level );
   4570a:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   4570c:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   4570e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  pending_events  = api->pending_events;
  event_condition = (rtems_event_set) the_thread->Wait.count;
   45710:	222a 0024      	movel %a2@(36),%d1                                	<== NOT EXECUTED
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];

  option_set = (rtems_option) the_thread->Wait.option;

  _ISR_Disable( level );
  pending_events  = api->pending_events;
   45714:	2610           	movel %a0@,%d3                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
  rtems_event_set the_event_set,
  rtems_event_set the_event_condition
)
{
   return ( the_event_set & the_event_condition );
   45716:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   45718:	c483           	andl %d3,%d2                                      	<== 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 ) ) {
   4571a:	6776           	beqs 45792 <_Event_Surrender+0xa2>                	<== 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() &&
   4571c:	2039 0005 87f2 	movel 587f2 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   45722:	670a           	beqs 4572e <_Event_Surrender+0x3e>                	<== NOT EXECUTED
   45724:	b5f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   4572a:	6700 00a2      	beqw 457ce <_Event_Surrender+0xde>                	<== NOT EXECUTED
  }

  /*
   *  Otherwise, this is a normal send to another thread
   */
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
   4572e:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   45732:	0280 0000 0100 	andil #256,%d0                                    	<== NOT EXECUTED
   45738:	674c           	beqs 45786 <_Event_Surrender+0x96>                	<== NOT EXECUTED
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
   4573a:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   4573c:	6706           	beqs 45744 <_Event_Surrender+0x54>                	<== NOT EXECUTED
   4573e:	0805 0001      	btst #1,%d5                                       	<== NOT EXECUTED
   45742:	6742           	beqs 45786 <_Event_Surrender+0x96>                	<== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
   45744:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45746:	4680           	notl %d0                                          	<== NOT EXECUTED
   45748:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED
   4574a:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = 0;
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   4574c:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   *  Otherwise, this is a normal send to another thread
   */
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
      the_thread->Wait.count = 0;
   45750:	42aa 0024      	clrl %a2@(36)                                     	<== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   45754:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED

      _ISR_Flash( level );
   45756:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4575c:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   4575e:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   45760:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   45762:	7c02           	moveq #2,%d6                                      	<== NOT EXECUTED
   45764:	bcaa 0050      	cmpl %a2@(80),%d6                                 	<== NOT EXECUTED
   45768:	6734           	beqs 4579e <_Event_Surrender+0xae>                	<== NOT EXECUTED
        _ISR_Enable( level );
   4576a:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   4576c:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   45772:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45774:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
   4577a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      }
      return;
    }
  }
  _ISR_Enable( level );
}
   4577c:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   45782:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45784:	4e75           	rts                                               	<== NOT EXECUTED
        _Thread_Unblock( the_thread );
      }
      return;
    }
  }
  _ISR_Enable( level );
   45786:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   45788:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   4578e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45790:	4e75           	rts                                               	<== NOT EXECUTED

  /*
   *  No events were seized in this operation
   */
  if ( _Event_sets_Is_empty( seized_events ) ) {
    _ISR_Enable( level );
   45792:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
      }
      return;
    }
  }
  _ISR_Enable( level );
}
   45794:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   4579a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4579c:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   4579e:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   457a0:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
        _ISR_Enable( level );
        _Thread_Unblock( the_thread );
      } else {
        _Watchdog_Deactivate( &the_thread->Timer );
        _ISR_Enable( level );
   457a4:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
        (void) _Watchdog_Remove( &the_thread->Timer );
   457a6:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   457aa:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   457b0:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   457b6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   457b8:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
   457be:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
      }
      return;
    }
  }
  _ISR_Enable( level );
}
   457c4:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   457ca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   457cc:	4e75           	rts                                               	<== 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() &&
   457ce:	2039 0005 898e 	movel 5898e <_Event_Sync_state>,%d0               	<== NOT EXECUTED
   457d4:	7c01           	moveq #1,%d6                                      	<== NOT EXECUTED
   457d6:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   457d8:	6710           	beqs 457ea <_Event_Surrender+0xfa>                	<== NOT EXECUTED
   457da:	2039 0005 898e 	movel 5898e <_Event_Sync_state>,%d0               	<== NOT EXECUTED
   457e0:	1c3c 0002      	moveb #2,%d6                                      	<== NOT EXECUTED
   457e4:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   457e6:	6600 ff46      	bnew 4572e <_Event_Surrender+0x3e>                	<== 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) ) {
   457ea:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   457ec:	6706           	beqs 457f4 <_Event_Surrender+0x104>               	<== NOT EXECUTED
   457ee:	0805 0001      	btst #1,%d5                                       	<== NOT EXECUTED
   457f2:	671a           	beqs 4580e <_Event_Surrender+0x11e>               	<== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
   457f4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   457f6:	4680           	notl %d0                                          	<== NOT EXECUTED
   457f8:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED
   457fa:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = 0;
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   457fc:	206a 0028      	moveal %a2@(40),%a0                               	<== 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) ) {
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
      the_thread->Wait.count = 0;
   45800:	42aa 0024      	clrl %a2@(36)                                     	<== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
   45804:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45806:	23c0 0005 898e 	movel %d0,5898e <_Event_Sync_state>               	<== NOT EXECUTED
       ((_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) ) {
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
      the_thread->Wait.count = 0;
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   4580c:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
    }
    _ISR_Enable( level );
   4580e:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
      }
      return;
    }
  }
  _ISR_Enable( level );
}
   45810:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   45816:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45818:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004581c <_Event_Timeout>:

void _Event_Timeout(
  Objects_Id  id,
  void       *ignored
)
{
   4581c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45820:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Thread_Control    *the_thread;
  Objects_Locations  location;
  ISR_Level          level;

  the_thread = _Thread_Get( id, &location );
   45822:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45826:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4582a:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   45830:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  Thread_Control    *the_thread;
  Objects_Locations  location;
  ISR_Level          level;

  the_thread = _Thread_Get( id, &location );
   45832:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   45834:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45838:	6644           	bnes 4587e <_Event_Timeout+0x62>                  	<== NOT EXECUTED
       *  this is the "timeout" transition.  After a request is satisfied,
       *  a timeout is not allowed to occur.
       */


      _ISR_Disable( level );
   4583a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   45840:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   45842:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   45844:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
        if ( !the_thread->Wait.count ) {  /* verify thread is waiting */
   45846:	4aa8 0024      	tstl %a0@(36)                                     	<== NOT EXECUTED
   4584a:	673a           	beqs 45886 <_Event_Timeout+0x6a>                  	<== NOT EXECUTED
          _Thread_Unnest_dispatch();
          _ISR_Enable( level );
          return;
        }

        the_thread->Wait.count = 0;
   4584c:	42a8 0024      	clrl %a0@(36)                                     	<== NOT EXECUTED
        if ( _Thread_Is_executing( the_thread ) ) {
   45850:	b1f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a0               	<== NOT EXECUTED
   45856:	6746           	beqs 4589e <_Event_Timeout+0x82>                  	<== NOT EXECUTED
               (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
          }
        }

        the_thread->Wait.return_code = RTEMS_TIMEOUT;
   45858:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
   4585a:	2142 0034      	movel %d2,%a0@(52)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   4585e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   45860:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   45866:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45868:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   4586e:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45874:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45876:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   45878:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */
#endif
    case OBJECTS_ERROR:
      break;
  }
}
   4587e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   45882:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45884:	4e75           	rts                                               	<== NOT EXECUTED
   45886:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4588c:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4588e:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED


      _ISR_Disable( level );
        if ( !the_thread->Wait.count ) {  /* verify thread is waiting */
          _Thread_Unnest_dispatch();
          _ISR_Enable( level );
   45894:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */
#endif
    case OBJECTS_ERROR:
      break;
  }
}
   45896:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4589a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4589c:	4e75           	rts                                               	<== NOT EXECUTED
          return;
        }

        the_thread->Wait.count = 0;
        if ( _Thread_Is_executing( the_thread ) ) {
          Thread_blocking_operation_States sync = _Event_Sync_state;
   4589e:	2039 0005 898e 	movel 5898e <_Event_Sync_state>,%d0               	<== NOT EXECUTED
          if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
   458a4:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   458a6:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   458a8:	65ae           	bcss 45858 <_Event_Timeout+0x3c>                  	<== NOT EXECUTED
               (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   458aa:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
          }
        }

        the_thread->Wait.return_code = RTEMS_TIMEOUT;
   458ac:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
        the_thread->Wait.count = 0;
        if ( _Thread_Is_executing( the_thread ) ) {
          Thread_blocking_operation_States sync = _Event_Sync_state;
          if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
               (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   458ae:	23c0 0005 898e 	movel %d0,5898e <_Event_Sync_state>               	<== NOT EXECUTED
          }
        }

        the_thread->Wait.return_code = RTEMS_TIMEOUT;
   458b4:	2142 0034      	movel %d2,%a0@(52)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   458b8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   458ba:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   458c0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   458c2:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   458c8:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   458ce:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   458d0:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   458d6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   458d8:	60a4           	bras 4587e <_Event_Timeout+0x62>                  	<== NOT EXECUTED
	...

00046358 <_Extension_Manager_initialization>:
 */

void _Extension_Manager_initialization(
  uint32_t   maximum_extensions
)
{
   46358:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4635c:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   46360:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46362:	4878 0044      	pea 44 <FP_REGS_SAVED+0x4>                        	<== NOT EXECUTED
   46366:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4636a:	4878 0009      	pea 9 <DIVIDE_BY_ZERO+0x1>                        	<== NOT EXECUTED
   4636e:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   46372:	4879 0005 8992 	pea 58992 <_Extension_Information>                	<== NOT EXECUTED
   46378:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4637e:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    false,                     /* true if this is a global object class */
    NULL                       /* Proxy extraction support callout */
#endif
  );
}
   46384:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46386:	4e75           	rts

0004b404 <_Heap_Allocate>:

void *_Heap_Allocate(
  Heap_Control        *the_heap,
  size_t               size
)
{
   4b404:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4b408:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4b40c:	266e 0008      	moveal %fp@(8),%a3                                	<== 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 =
   4b410:	2f2b 0014      	movel %a3@(20),%sp@-                              	<== NOT EXECUTED
   4b414:	2f2b 0010      	movel %a3@(16),%sp@-                              	<== NOT EXECUTED
   4b418:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4b41c:	4eb9 0004 6d6e 	jsr 46d6e <_Heap_Calc_block_size>                 	<== NOT EXECUTED
    _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
  if(the_size == 0)
   4b422:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4b428:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b42a:	675c           	beqs 4b488 <_Heap_Allocate+0x84>                  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   4b42c:	246b 0008      	moveal %a3@(8),%a2                                	<== NOT EXECUTED
    return NULL;

  /* Find large enough free block. */
  for(the_block = _Heap_First(the_heap), search_count = 0;
      the_block != tail;
   4b430:	b5cb           	cmpal %a3,%a2                                     	<== NOT EXECUTED
   4b432:	6754           	beqs 4b488 <_Heap_Allocate+0x84>                  	<== 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) {
   4b434:	b0aa 0004      	cmpl %a2@(4),%d0                                  	<== NOT EXECUTED
   4b438:	6360           	blss 4b49a <_Heap_Allocate+0x96>                  	<== NOT EXECUTED

      stats->allocs += 1;
      stats->searches += search_count + 1;

      _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
      break;
   4b43a:	4282           	clrl %d2                                          	<== 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)
   4b43c:	246a 0008      	moveal %a2@(8),%a2                                	<== NOT EXECUTED
   4b440:	5282           	addql #1,%d2                                      	<== 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;
   4b442:	b5cb           	cmpal %a3,%a2                                     	<== NOT EXECUTED
   4b444:	674e           	beqs 4b494 <_Heap_Allocate+0x90>                  	<== 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) {
   4b446:	b0aa 0004      	cmpl %a2@(4),%d0                                  	<== NOT EXECUTED
   4b44a:	62f0           	bhis 4b43c <_Heap_Allocate+0x38>                  	<== NOT EXECUTED
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );
   4b44c:	2f00           	movel %d0,%sp@-                                   	<== 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) {
   4b44e:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );
   4b450:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b452:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4b454:	4eb9 0004 6daa 	jsr 46daa <_Heap_Block_allocate>                  	<== NOT EXECUTED

      ptr = _Heap_User_area(the_block);

      stats->allocs += 1;
      stats->searches += search_count + 1;
   4b45a:	222b 004c      	movel %a3@(76),%d1                                	<== NOT EXECUTED
   4b45e:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4b460:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   4b462:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   4b464:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
   4b466:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4b46c:	2741 004c      	movel %d1,%a3@(76)                                	<== NOT EXECUTED
    if(the_block->size >= the_size) {
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );

      ptr = _Heap_User_area(the_block);

      stats->allocs += 1;
   4b470:	52ab 0048      	addql #1,%a3@(72)                                 	<== NOT EXECUTED
      _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
      break;
    }
  }

  if(stats->max_search < search_count)
   4b474:	b6ab 0044      	cmpl %a3@(68),%d3                                 	<== NOT EXECUTED
   4b478:	6304           	blss 4b47e <_Heap_Allocate+0x7a>                  	<== NOT EXECUTED
    stats->max_search = search_count;
   4b47a:	2743 0044      	movel %d3,%a3@(68)                                	<== NOT EXECUTED

  return ptr;
}
   4b47e:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   4b484:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b486:	4e75           	rts                                               	<== NOT EXECUTED
   4b488:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   4b48e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      break;
    }
  }

  if(stats->max_search < search_count)
    stats->max_search = search_count;
   4b490:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return ptr;
}
   4b492:	4e75           	rts                                               	<== 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;
   4b494:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   4b496:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b498:	60da           	bras 4b474 <_Heap_Allocate+0x70>                  	<== NOT EXECUTED
    _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) {
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );
   4b49a:	2f00           	movel %d0,%sp@-                                   	<== 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) {
   4b49c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4b49e:	4283           	clrl %d3                                          	<== NOT EXECUTED
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );
   4b4a0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b4a2:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4b4a4:	4eb9 0004 6daa 	jsr 46daa <_Heap_Block_allocate>                  	<== NOT EXECUTED

      ptr = _Heap_User_area(the_block);

      stats->allocs += 1;
      stats->searches += search_count + 1;
   4b4aa:	222b 004c      	movel %a3@(76),%d1                                	<== NOT EXECUTED
    if(the_block->size >= the_size) {
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );

      ptr = _Heap_User_area(the_block);

      stats->allocs += 1;
   4b4ae:	52ab 0048      	addql #1,%a3@(72)                                 	<== NOT EXECUTED
      stats->searches += search_count + 1;
   4b4b2:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   4b4b4:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   4b4b6:	2741 004c      	movel %d1,%a3@(76)                                	<== NOT EXECUTED
   4b4ba:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4b4bc:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
   4b4be:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4b4c4:	60ae           	bras 4b474 <_Heap_Allocate+0x70>                  	<== NOT EXECUTED
	...

00049c40 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   49c40:	4e56 ffd4      	linkw %fp,#-44                                    	<== NOT EXECUTED
   49c44:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   49c48:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  Heap_Block *const tail = _Heap_Tail(the_heap);

  uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;

  uint32_t const the_size =
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
   49c4c:	2f2b 0014      	movel %a3@(20),%sp@-                              	<== NOT EXECUTED
{
  uint32_t search_count;
  Heap_Block *the_block;

  void *user_ptr = NULL;
  uint32_t  const page_size = the_heap->page_size;
   49c50:	2e2b 0010      	movel %a3@(16),%d7                                	<== NOT EXECUTED
  Heap_Block *const tail = _Heap_Tail(the_heap);

  uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;

  uint32_t const the_size =
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
   49c54:	2f07           	movel %d7,%sp@-                                   	<== NOT EXECUTED
void *_Heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   49c56:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   49c5a:	2a2e 0010      	movel %fp@(16),%d5                                	<== NOT EXECUTED
  Heap_Block *const tail = _Heap_Tail(the_heap);

  uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;

  uint32_t const the_size =
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
   49c5e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
  void *user_ptr = NULL;
  uint32_t  const page_size = the_heap->page_size;
  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;
   49c60:	5980           	subql #4,%d0                                      	<== NOT EXECUTED
   49c62:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED

  uint32_t const the_size =
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
   49c66:	4eb9 0004 a10a 	jsr 4a10a <_Heap_Calc_block_size>                 	<== NOT EXECUTED

  if(the_size == 0)
   49c6c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  Heap_Block *const tail = _Heap_Tail(the_heap);

  uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;

  uint32_t const the_size =
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
   49c72:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED

  if(the_size == 0)
   49c74:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49c76:	6700 00ac      	beqw 49d24 <_Heap_Allocate_aligned+0xe4>          	<== NOT EXECUTED
    return NULL;

  if(alignment == 0)
   49c7a:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   49c7c:	6700 009e      	beqw 49d1c <_Heap_Allocate_aligned+0xdc>          	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   49c80:	246b 0008      	moveal %a3@(8),%a2                                	<== 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;
   49c84:	b5cb           	cmpal %a3,%a2                                     	<== NOT EXECUTED
   49c86:	6700 009c      	beqw 49d24 <_Heap_Allocate_aligned+0xe4>          	<== NOT EXECUTED
   49c8a:	4286           	clrl %d6                                          	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   49c8c:	78fe           	moveq #-2,%d4                                     	<== NOT EXECUTED
   49c8e:	c8aa 0004      	andl %a2@(4),%d4                                  	<== 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. */
   49c92:	b88c           	cmpl %a4,%d4                                      	<== NOT EXECUTED
   49c94:	6540           	bcss 49cd6 <_Heap_Allocate_aligned+0x96>          	<== 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;
   49c96:	43f2 4800      	lea %a2@(00000000,%d4:l),%a1                      	<== NOT EXECUTED
      aligned_user_addr = block_end - end_to_user_offs;
   49c9a:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   49c9c:	90ae fffc      	subl %fp@(-4),%d0                                 	<== NOT EXECUTED
  _H_uptr_t *value,
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  *value = v - (v % alignment);
   49ca0:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   49ca2:	4c45 2001      	remul %d5,%d1,%d2                                 	<== NOT EXECUTED
   49ca6:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
   49ca8:	9681           	subl %d1,%d3                                      	<== NOT EXECUTED

    if(block_size >= the_size) { /* the_block is large enough. */

      _H_uptr_t user_addr;
      _H_uptr_t aligned_user_addr;
      _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
   49caa:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   49cac:	4c47 0002      	remul %d7,%d2,%d0                                 	<== NOT EXECUTED
   49cb0:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   49cb2:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
   49cb4:	220a           	movel %a2,%d1                                     	<== NOT EXECUTED
   49cb6:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   49cb8:	5081           	addql #8,%d1                                      	<== 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) {
   49cba:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   49cbc:	6518           	bcss 49cd6 <_Heap_Allocate_aligned+0x96>          	<== 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) {
   49cbe:	2a6b 0014      	moveal %a3@(20),%a5                               	<== NOT EXECUTED
   49cc2:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   49cc4:	bbc0           	cmpal %d0,%a5                                     	<== NOT EXECUTED
   49cc6:	630a           	blss 49cd2 <_Heap_Allocate_aligned+0x92>          	<== 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) {
   49cc8:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   49cca:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   49ccc:	b087           	cmpl %d7,%d0                                      	<== NOT EXECUTED
   49cce:	6426           	bccs 49cf6 <_Heap_Allocate_aligned+0xb6>          	<== NOT EXECUTED
   49cd0:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
              aligned_user_addr = 0;
            }
          }
        }

        if(aligned_user_addr) {
   49cd2:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   49cd4:	665a           	bnes 49d30 <_Heap_Allocate_aligned+0xf0>          	<== 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)
   49cd6:	246a 0008      	moveal %a2@(8),%a2                                	<== NOT EXECUTED
   49cda:	5286           	addql #1,%d6                                      	<== 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;
   49cdc:	b5cb           	cmpal %a3,%a2                                     	<== NOT EXECUTED
   49cde:	66ac           	bnes 49c8c <_Heap_Allocate_aligned+0x4c>          	<== NOT EXECUTED
   49ce0:	4280           	clrl %d0                                          	<== NOT EXECUTED
        }
      }
    }
  }

  if(stats->max_search < search_count)
   49ce2:	bcab 0044      	cmpl %a3@(68),%d6                                 	<== NOT EXECUTED
   49ce6:	6304           	blss 49cec <_Heap_Allocate_aligned+0xac>          	<== NOT EXECUTED
    stats->max_search = search_count;
   49ce8:	2746 0044      	movel %d6,%a3@(68)                                	<== NOT EXECUTED

  return user_ptr;
}
   49cec:	4cee 3cfc ffd4 	moveml %fp@(-44),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   49cf2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49cf4:	4e75           	rts                                               	<== NOT EXECUTED
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  uint32_t a = alignment;
  _H_uptr_t r = v % a;
   49cf6:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49cf8:	4c45 0002      	remul %d5,%d2,%d0                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   49cfc:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   49cfe:	6716           	beqs 49d16 <_Heap_Allocate_aligned+0xd6>          	<== NOT EXECUTED
   49d00:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49d02:	d085           	addl %d5,%d0                                      	<== NOT EXECUTED
   49d04:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
   49d06:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   49d08:	91c1           	subal %d1,%a0                                     	<== 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) {
   49d0a:	b1c7           	cmpal %d7,%a0                                     	<== NOT EXECUTED
   49d0c:	64c8           	bccs 49cd6 <_Heap_Allocate_aligned+0x96>          	<== NOT EXECUTED
   49d0e:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   49d10:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
              aligned_user_addr = 0;
            }
          }
        }

        if(aligned_user_addr) {
   49d12:	67c2           	beqs 49cd6 <_Heap_Allocate_aligned+0x96>          	<== NOT EXECUTED
   49d14:	601a           	bras 49d30 <_Heap_Allocate_aligned+0xf0>          	<== NOT EXECUTED
   49d16:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49d18:	91c8           	subal %a0,%a0                                     	<== NOT EXECUTED
   49d1a:	60ee           	bras 49d0a <_Heap_Allocate_aligned+0xca>          	<== NOT EXECUTED
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size);

  if(the_size == 0)
    return NULL;

  if(alignment == 0)
   49d1c:	1a3c 0004      	moveb #4,%d5                                      	<== NOT EXECUTED
   49d20:	6000 ff5e      	braw 49c80 <_Heap_Allocate_aligned+0x40>          	<== NOT EXECUTED

  if(stats->max_search < search_count)
    stats->max_search = search_count;

  return user_ptr;
}
   49d24:	4cee 3cfc ffd4 	moveml %fp@(-44),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   49d2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      }
    }
  }

  if(stats->max_search < search_count)
    stats->max_search = search_count;
   49d2c:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return user_ptr;
}
   49d2e:	4e75           	rts                                               	<== NOT EXECUTED
        if(aligned_user_addr) {

          /* 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;
   49d30:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   49d32:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
   49d34:	9082           	subl %d2,%d0                                      	<== 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;
   49d36:	2204           	movel %d4,%d1                                     	<== NOT EXECUTED
   49d38:	9280           	subl %d0,%d1                                      	<== 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) {
   49d3a:	bbc1           	cmpal %d1,%a5                                     	<== NOT EXECUTED
   49d3c:	6244           	bhis 49d82 <_Heap_Allocate_aligned+0x142>         	<== 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;
   49d3e:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   49d40:	8481           	orl %d1,%d2                                       	<== NOT EXECUTED
   49d42:	2542 0004      	movel %d2,%a2@(4)                                 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
  void       *base,
  uint32_t    offset
)
{
  return (void *)((char *)base + offset);
   49d46:	d5c1           	addal %d1,%a2                                     	<== NOT EXECUTED
    the_block = _Heap_Block_at(the_block, the_rest);
    the_block->prev_size = the_rest;
   49d48:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
    the_block->size = alloc_size;
   49d4a:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
    _Heap_Block_remove(the_block);
    alloc_size = block_size;
    stats->free_blocks -= 1;
  }
  /* Mark the block as used (in the next block). */
  _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
   49d4e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49d50:	83b2 0804      	orl %d1,%a2@(00000004,%d0:l)                      	<== NOT EXECUTED
  /* Update statistics */
  stats->free_size -= alloc_size;
   49d54:	242b 0030      	movel %a3@(48),%d2                                	<== NOT EXECUTED
   49d58:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   49d5a:	2742 0030      	movel %d2,%a3@(48)                                	<== NOT EXECUTED
  if(stats->min_free_size > stats->free_size)
   49d5e:	b4ab 0034      	cmpl %a3@(52),%d2                                 	<== NOT EXECUTED
   49d62:	6404           	bccs 49d68 <_Heap_Allocate_aligned+0x128>         	<== NOT EXECUTED
    stats->min_free_size = stats->free_size;
   49d64:	2742 0034      	movel %d2,%a3@(52)                                	<== 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;
   49d68:	202b 004c      	movel %a3@(76),%d0                                	<== NOT EXECUTED
  _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
  /* Update statistics */
  stats->free_size -= alloc_size;
  if(stats->min_free_size > stats->free_size)
    stats->min_free_size = stats->free_size;
  stats->used_blocks += 1;
   49d6c:	52ab 0040      	addql #1,%a3@(64)                                 	<== 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;
   49d70:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
          stats->allocs += 1;
   49d72:	52ab 0048      	addql #1,%a3@(72)                                 	<== 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;
   49d76:	d086           	addl %d6,%d0                                      	<== NOT EXECUTED
   49d78:	2740 004c      	movel %d0,%a3@(76)                                	<== NOT EXECUTED
          stats->allocs += 1;

          check_result(the_heap, the_block, user_addr,
            aligned_user_addr, size);

          user_ptr = (void*)aligned_user_addr;
   49d7c:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   49d7e:	6000 ff62      	braw 49ce2 <_Heap_Allocate_aligned+0xa2>          	<== NOT EXECUTED
  Heap_Block *the_block
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
   49d82:	226a 0008      	moveal %a2@(8),%a1                                	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
   49d86:	206a 000c      	moveal %a2@(12),%a0                               	<== 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;
   49d8a:	53ab 0038      	subql #1,%a3@(56)                                 	<== NOT EXECUTED
   49d8e:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
  prev->next = next;
  next->prev = prev;
   49d90:	2348 000c      	movel %a0,%a1@(12)                                	<== NOT EXECUTED
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
   49d94:	2149 0008      	movel %a1,%a0@(8)                                 	<== NOT EXECUTED
   49d98:	60b4           	bras 49d4e <_Heap_Allocate_aligned+0x10e>         	<== NOT EXECUTED
	...

00046daa <_Heap_Block_allocate>:
uint32_t _Heap_Block_allocate(
  Heap_Control* the_heap,
  Heap_Block*   the_block,
  uint32_t      alloc_size
)
{
   46daa:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   46dae:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   46db2:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   46db6:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   46dba:	72fe           	moveq #-2,%d1                                     	<== NOT EXECUTED
   46dbc:	c2ab 0004      	andl %a3@(4),%d1                                  	<== NOT EXECUTED
   46dc0:	286e 0008      	moveal %fp@(8),%a4                                	<== 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;
   46dc4:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   46dc6:	9082           	subl %d2,%d0                                      	<== 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) {
   46dc8:	b0ac 0014      	cmpl %a4@(20),%d0                                 	<== NOT EXECUTED
   46dcc:	6552           	bcss 46e20 <_Heap_Block_allocate+0x76>            	<== NOT EXECUTED
  Heap_Block *old_block,
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
   46dce:	246b 0008      	moveal %a3@(8),%a2                                	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
   46dd2:	226b 000c      	moveal %a3@(12),%a1                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   46dd6:	41f3 2800      	lea %a3@(00000000,%d2:l),%a0                      	<== 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;
   46dda:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46ddc:	8282           	orl %d2,%d1                                       	<== NOT EXECUTED
   46dde:	2741 0004      	movel %d1,%a3@(4)                                 	<== NOT EXECUTED
    next_block->size = the_rest | HEAP_PREV_USED;
   46de2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46de4:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   46de6:	214a 0008      	movel %a2,%a0@(8)                                 	<== NOT EXECUTED
    _Heap_Block_at(next_block, the_rest)->prev_size = the_rest;
   46dea:	2180 0800      	movel %d0,%a0@(00000000,%d0:l)                    	<== NOT EXECUTED
  block->prev = prev;
   46dee:	2149 000c      	movel %a1,%a0@(12)                                	<== NOT EXECUTED
       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;
    next_block->size = the_rest | HEAP_PREV_USED;
   46df2:	2141 0004      	movel %d1,%a0@(4)                                 	<== NOT EXECUTED
  next->prev = prev->next = block;
   46df6:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
   46dfa:	2548 000c      	movel %a0,%a2@(12)                                	<== NOT EXECUTED
    alloc_size = block_size;
    _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
    stats->free_blocks -= 1;
  }
  /* Update statistics */
  stats->free_size -= alloc_size;
   46dfe:	222c 0030      	movel %a4@(48),%d1                                	<== NOT EXECUTED
   46e02:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED
   46e04:	2941 0030      	movel %d1,%a4@(48)                                	<== NOT EXECUTED
  if(stats->min_free_size > stats->free_size)
   46e08:	b2ac 0034      	cmpl %a4@(52),%d1                                 	<== NOT EXECUTED
   46e0c:	6404           	bccs 46e12 <_Heap_Block_allocate+0x68>            	<== NOT EXECUTED
    stats->min_free_size = stats->free_size;
   46e0e:	2941 0034      	movel %d1,%a4@(52)                                	<== NOT EXECUTED
  stats->used_blocks += 1;
   46e12:	52ac 0040      	addql #1,%a4@(64)                                 	<== NOT EXECUTED
  return alloc_size;
}
   46e16:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46e18:	4cd7 1c04      	moveml %sp@,%d2/%a2-%a4                           	<== NOT EXECUTED
   46e1c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46e1e:	4e75           	rts                                               	<== 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;
   46e20:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  Heap_Block *the_block
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
   46e22:	226b 0008      	moveal %a3@(8),%a1                                	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
   46e26:	206b 000c      	moveal %a3@(12),%a0                               	<== NOT EXECUTED
   46e2a:	81b3 1804      	orl %d0,%a3@(00000004,%d1:l)                      	<== NOT EXECUTED
    stats->free_blocks -= 1;
   46e2e:	53ac 0038      	subql #1,%a4@(56)                                 	<== NOT EXECUTED
   46e32:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
  prev->next = next;
  next->prev = prev;
   46e34:	2348 000c      	movel %a0,%a1@(12)                                	<== NOT EXECUTED
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
   46e38:	2149 0008      	movel %a1,%a0@(8)                                 	<== NOT EXECUTED
   46e3c:	60c0           	bras 46dfe <_Heap_Block_allocate+0x54>            	<== NOT EXECUTED
	...

00046d6e <_Heap_Calc_block_size>:
 */
size_t _Heap_Calc_block_size(
  size_t   size,
  uint32_t page_size,
  uint32_t min_size)
{
   46d6e:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46d72:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   46d76:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46d78:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
  uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD;
   46d7c:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   46d7e:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
 */
size_t _Heap_Calc_block_size(
  size_t   size,
  uint32_t page_size,
  uint32_t min_size)
{
   46d80:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   46d84:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   46d86:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
   46d88:	4c41 3002      	remul %d1,%d2,%d3                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   46d8c:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   46d8e:	6704           	beqs 46d94 <_Heap_Calc_block_size+0x26>           	<== NOT EXECUTED
   46d90:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   46d92:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
   46d94:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   46d96:	6302           	blss 46d9a <_Heap_Calc_block_size+0x2c>           	<== NOT EXECUTED
   46d98:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
  uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD;
  _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;
}
   46d9a:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   46d9c:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
{
  uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD;
  _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;
   46d9e:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   46da0:	52c1           	shi %d1                                           	<== NOT EXECUTED
   46da2:	49c1           	extbl %d1                                         	<== NOT EXECUTED
}
   46da4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46da6:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   46da8:	4e75           	rts

0004ea54 <_Heap_Extend>:
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t               size,
  uint32_t            *amount_extended
)
{
   4ea54:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4ea58:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4ea5a:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4ea5e:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   4ea62:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   *    5. non-contiguous higher address    (NOT SUPPORTED)
   *
   *  As noted, this code only supports (4).
   */

  if ( starting_address >= the_heap->begin &&        /* case 3 */
   4ea64:	b0a9 0018      	cmpl %a1@(24),%d0                                 	<== NOT EXECUTED
   4ea68:	6416           	bccs 4ea80 <_Heap_Extend+0x2c>                    	<== NOT EXECUTED
   4ea6a:	2229 001c      	movel %a1@(28),%d1                                	<== NOT EXECUTED
       starting_address < the_heap->end
     )
    return HEAP_EXTEND_ERROR;

  if ( starting_address != the_heap->end )
   4ea6e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ea70:	6724           	beqs 4ea96 <_Heap_Extend+0x42>                    	<== NOT EXECUTED
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );

  return HEAP_EXTEND_SUCCESSFUL;
}
   4ea72:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4ea76:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4ea7a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  if ( starting_address >= the_heap->begin &&        /* case 3 */
       starting_address < the_heap->end
     )
    return HEAP_EXTEND_ERROR;

  if ( starting_address != the_heap->end )
   4ea7c:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );

  return HEAP_EXTEND_SUCCESSFUL;
}
   4ea7e:	4e75           	rts                                               	<== NOT EXECUTED
   *    5. non-contiguous higher address    (NOT SUPPORTED)
   *
   *  As noted, this code only supports (4).
   */

  if ( starting_address >= the_heap->begin &&        /* case 3 */
   4ea80:	2229 001c      	movel %a1@(28),%d1                                	<== NOT EXECUTED
   4ea84:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ea86:	63e6           	blss 4ea6e <_Heap_Extend+0x1a>                    	<== NOT EXECUTED
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );

  return HEAP_EXTEND_SUCCESSFUL;
}
   4ea88:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4ea8c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4ea90:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *    5. non-contiguous higher address    (NOT SUPPORTED)
   *
   *  As noted, this code only supports (4).
   */

  if ( starting_address >= the_heap->begin &&        /* case 3 */
   4ea92:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );

  return HEAP_EXTEND_SUCCESSFUL;
}
   4ea94:	4e75           	rts                                               	<== NOT EXECUTED
   4ea96:	d0ae 0010      	addl %fp@(16),%d0                                 	<== 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;
   4ea9a:	2469 0024      	moveal %a1@(36),%a2                               	<== NOT EXECUTED
  the_heap->end = _Addresses_Add_offset( the_heap->end, size );
   4ea9e:	2340 001c      	movel %d0,%a1@(28)                                	<== NOT EXECUTED
  the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
   4eaa2:	908a           	subl %a2,%d0                                      	<== NOT EXECUTED
   4eaa4:	5180           	subql #8,%d0                                      	<== NOT EXECUTED
  _Heap_Align_down( &the_size, the_heap->page_size );

  *amount_extended = size;
   4eaa6:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   4eaaa:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4eaac:	4c69 2001 0010 	remul %a1@(16),%d1,%d2                            	<== NOT EXECUTED
   4eab2:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   4eab4:	20ae 0010      	movel %fp@(16),%a0@                               	<== NOT EXECUTED
   4eab8:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED

  if( the_size < the_heap->min_block_size )
   4eaba:	b0a9 0014      	cmpl %a1@(20),%d0                                 	<== NOT EXECUTED
   4eabe:	640e           	bccs 4eace <_Heap_Extend+0x7a>                    	<== NOT EXECUTED

  stats->size += size;
  stats->used_blocks += 1;
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );
   4eac0:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return HEAP_EXTEND_SUCCESSFUL;
}
   4eac2:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4eac6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4eaca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4eacc:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4eace:	41f2 0800      	lea %a2@(00000000,%d0:l),%a0                      	<== NOT EXECUTED
  *amount_extended = size;

  if( the_size < the_heap->min_block_size )
    return HEAP_EXTEND_SUCCESSFUL;

  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
   4ead2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ead4:	c0aa 0004      	andl %a2@(4),%d0                                  	<== NOT EXECUTED
   4ead8:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4eada:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  new_final = _Heap_Block_at( old_final, the_size );
  new_final->size = HEAP_PREV_USED;
   4eade:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4eae0:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED

  stats->size += size;
  stats->used_blocks += 1;
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );
   4eae4:	486a 0008      	pea %a2@(8)                                       	<== NOT EXECUTED
  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
  new_final = _Heap_Block_at( old_final, the_size );
  new_final->size = HEAP_PREV_USED;
  the_heap->final = new_final;

  stats->size += size;
   4eae8:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
  stats->used_blocks += 1;
   4eaec:	52a9 0040      	addql #1,%a1@(64)                                 	<== NOT EXECUTED
  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
  new_final = _Heap_Block_at( old_final, the_size );
  new_final->size = HEAP_PREV_USED;
  the_heap->final = new_final;

  stats->size += size;
   4eaf0:	d3a9 002c      	addl %d1,%a1@(44)                                 	<== NOT EXECUTED
  stats->used_blocks += 1;
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */
   4eaf4:	53a9 0050      	subql #1,%a1@(80)                                 	<== NOT EXECUTED

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );
   4eaf8:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
    return HEAP_EXTEND_SUCCESSFUL;

  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
  new_final = _Heap_Block_at( old_final, the_size );
  new_final->size = HEAP_PREV_USED;
  the_heap->final = new_final;
   4eafa:	2348 0024      	movel %a0,%a1@(36)                                	<== NOT EXECUTED

  stats->size += size;
  stats->used_blocks += 1;
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );
   4eafe:	4eb9 0004 9e60 	jsr 49e60 <_Heap_Free>                            	<== NOT EXECUTED
   4eb04:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4eb06:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4eb08:	60b8           	bras 4eac2 <_Heap_Extend+0x6e>                    	<== NOT EXECUTED
	...

0004b4c8 <_Heap_Free>:

bool _Heap_Free(
  Heap_Control        *the_heap,
  void                *starting_address
)
{
   4b4c8:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4b4cc:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4b4d0:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4b4d4:	222e 000c      	movel %fp@(12),%d1                                	<== 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(
   4b4d8:	226b 0024      	moveal %a3@(36),%a1                               	<== NOT EXECUTED
   4b4dc:	206b 0020      	moveal %a3@(32),%a0                               	<== NOT EXECUTED
  void *address,
  void *base,
  void *limit
)
{
  return (address >= base && address <= limit);
   4b4e0:	b288           	cmpl %a0,%d1                                      	<== NOT EXECUTED
   4b4e2:	6504           	bcss 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
   4b4e4:	b289           	cmpl %a1,%d1                                      	<== NOT EXECUTED
   4b4e6:	630a           	blss 4b4f2 <_Heap_Free+0x2a>                      	<== NOT EXECUTED
  stats->used_blocks -= 1;
  stats->free_size += the_size;
  stats->frees += 1;

  return( TRUE );
}
   4b4e8:	4cd7 1c1c      	moveml %sp@,%d2-%d4/%a2-%a4                       	<== NOT EXECUTED
   4b4ec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  stats->used_blocks -= 1;
  stats->free_size += the_size;
  stats->frees += 1;

  return( TRUE );
   4b4ee:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   4b4f0:	4e75           	rts                                               	<== NOT EXECUTED
  /* The address passed could be greater than the block address plus
   * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
   * pointers. To get rid of this offset we need to align the address down
   * to the nearest 'page_size' boundary. */
  _Heap_Align_down_uptr ( &addr, the_heap->page_size );
  *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
   4b4f2:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   4b4f4:	2441           	moveal %d1,%a2                                    	<== NOT EXECUTED
   4b4f6:	4c6b 2000 0010 	remul %a3@(16),%d0,%d2                            	<== NOT EXECUTED
   4b4fc:	518a           	subql #8,%a2                                      	<== NOT EXECUTED
   4b4fe:	95c0           	subal %d0,%a2                                     	<== NOT EXECUTED
   4b500:	b5c8           	cmpal %a0,%a2                                     	<== NOT EXECUTED
   4b502:	65e4           	bcss 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
   4b504:	b5c9           	cmpal %a1,%a2                                     	<== NOT EXECUTED
   4b506:	62e0           	bhis 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4b508:	222a 0004      	movel %a2@(4),%d1                                 	<== NOT EXECUTED
   4b50c:	76fe           	moveq #-2,%d3                                     	<== NOT EXECUTED
   4b50e:	c681           	andl %d1,%d3                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4b510:	49f2 3800      	lea %a2@(00000000,%d3:l),%a4                      	<== NOT EXECUTED
   4b514:	b9c8           	cmpal %a0,%a4                                     	<== NOT EXECUTED
   4b516:	65d0           	bcss 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
   4b518:	b9c9           	cmpal %a1,%a4                                     	<== NOT EXECUTED
   4b51a:	62cc           	bhis 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   4b51c:	242c 0004      	movel %a4@(4),%d2                                 	<== NOT EXECUTED
  if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
    _HAssert( FALSE );
    return( FALSE );
  }

  if ( !_Heap_Is_prev_used( next_block ) ) {
   4b520:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4b522:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   4b524:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4b526:	67c0           	beqs 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4b528:	78fe           	moveq #-2,%d4                                     	<== NOT EXECUTED
   4b52a:	c882           	andl %d2,%d4                                      	<== NOT EXECUTED
    _HAssert( FALSE );
    return( FALSE );
  }

  next_size = _Heap_Block_size( next_block );
  next_is_free = next_block < the_heap->final &&
   4b52c:	b9c9           	cmpal %a1,%a4                                     	<== NOT EXECUTED
   4b52e:	6560           	bcss 4b590 <_Heap_Free+0xc8>                      	<== NOT EXECUTED
   4b530:	4202           	clrb %d2                                          	<== NOT EXECUTED
    !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));

  if ( !_Heap_Is_prev_used( the_block ) ) {
   4b532:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4b534:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
   4b536:	4a01           	tstb %d1                                          	<== NOT EXECUTED
   4b538:	6662           	bnes 4b59c <_Heap_Free+0xd4>                      	<== NOT EXECUTED
    uint32_t const prev_size = the_block->prev_size;
   4b53a:	2212           	movel %a2@,%d1                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4b53c:	95c1           	subal %d1,%a2                                     	<== NOT EXECUTED
   4b53e:	b5c8           	cmpal %a0,%a2                                     	<== NOT EXECUTED
   4b540:	65a6           	bcss 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
   4b542:	b5c9           	cmpal %a1,%a2                                     	<== NOT EXECUTED
   4b544:	62a2           	bhis 4b4e8 <_Heap_Free+0x20>                      	<== 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) ) {
   4b546:	c0aa 0004      	andl %a2@(4),%d0                                  	<== NOT EXECUTED
   4b54a:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4b54c:	679a           	beqs 4b4e8 <_Heap_Free+0x20>                      	<== NOT EXECUTED
      _HAssert( FALSE );
      return( FALSE );
    }

    if ( next_is_free ) {       /* coalesce both */
   4b54e:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4b550:	6700 00d2      	beqw 4b624 <_Heap_Free+0x15c>                     	<== NOT EXECUTED
      uint32_t const size = the_size + prev_size + next_size;
      _Heap_Block_remove( next_block );
      stats->free_blocks -= 1;
   4b554:	53ab 0038      	subql #1,%a3@(56)                                 	<== NOT EXECUTED
      _HAssert( FALSE );
      return( FALSE );
    }

    if ( next_is_free ) {       /* coalesce both */
      uint32_t const size = the_size + prev_size + next_size;
   4b558:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   4b55a:	d084           	addl %d4,%d0                                      	<== NOT EXECUTED
   4b55c:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
   4b55e:	226c 000c      	moveal %a4@(12),%a1                               	<== NOT EXECUTED
  Heap_Block *the_block
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
   4b562:	206c 0008      	moveal %a4@(8),%a0                                	<== NOT EXECUTED
      _Heap_Block_remove( next_block );
      stats->free_blocks -= 1;
      prev_block->size = size | HEAP_PREV_USED;
   4b566:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4b568:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
      next_block = _Heap_Block_at( prev_block, size );
      _HAssert(!_Heap_Is_prev_used( next_block));
      next_block->prev_size = size;
   4b56a:	2580 0800      	movel %d0,%a2@(00000000,%d0:l)                    	<== NOT EXECUTED

    if ( next_is_free ) {       /* coalesce both */
      uint32_t const size = the_size + prev_size + next_size;
      _Heap_Block_remove( next_block );
      stats->free_blocks -= 1;
      prev_block->size = size | HEAP_PREV_USED;
   4b56e:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
  prev->next = next;
  next->prev = prev;
   4b572:	2149 000c      	movel %a1,%a0@(12)                                	<== NOT EXECUTED
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
   4b576:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
  stats->frees += 1;
   4b57a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
   4b57c:	d7ab 0030      	addl %d3,%a3@(48)                                 	<== NOT EXECUTED
  stats->frees += 1;
   4b580:	52ab 0050      	addql #1,%a3@(80)                                 	<== NOT EXECUTED
    stats->free_blocks += 1;
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
   4b584:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
  stats->free_size += the_size;
  stats->frees += 1;

  return( TRUE );
}
   4b588:	4cd7 1c1c      	moveml %sp@,%d2-%d4/%a2-%a4                       	<== NOT EXECUTED
   4b58c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b58e:	4e75           	rts                                               	<== NOT EXECUTED
    _HAssert( FALSE );
    return( FALSE );
  }

  next_size = _Heap_Block_size( next_block );
  next_is_free = next_block < the_heap->final &&
   4b590:	2034 4804      	movel %a4@(00000004,%d4:l),%d0                    	<== NOT EXECUTED
   4b594:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4b596:	b580           	eorl %d2,%d0                                      	<== NOT EXECUTED
   4b598:	c480           	andl %d0,%d2                                      	<== NOT EXECUTED
   4b59a:	6096           	bras 4b532 <_Heap_Free+0x6a>                      	<== NOT EXECUTED
      prev_block->size = size | HEAP_PREV_USED;
      next_block->size &= ~HEAP_PREV_USED;
      next_block->prev_size = size;
    }
  }
  else if ( next_is_free ) {    /* coalesce next */
   4b59c:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4b59e:	6738           	beqs 4b5d8 <_Heap_Free+0x110>                     	<== NOT EXECUTED
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
   4b5a0:	206c 000c      	moveal %a4@(12),%a0                               	<== NOT EXECUTED
  Heap_Block *old_block,
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
   4b5a4:	226c 0008      	moveal %a4@(8),%a1                                	<== NOT EXECUTED
    uint32_t const size = the_size + next_size;
   4b5a8:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   4b5aa:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED
    _Heap_Block_replace( next_block, the_block );
    the_block->size = size | HEAP_PREV_USED;
   4b5ac:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
    next_block  = _Heap_Block_at( the_block, size );
    next_block->prev_size = size;
   4b5ae:	2580 0800      	movel %d0,%a2@(00000000,%d0:l)                    	<== NOT EXECUTED
    }
  }
  else if ( next_is_free ) {    /* coalesce next */
    uint32_t const size = the_size + next_size;
    _Heap_Block_replace( next_block, the_block );
    the_block->size = size | HEAP_PREV_USED;
   4b5b2:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
  stats->frees += 1;
   4b5b4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    }
  }
  else if ( next_is_free ) {    /* coalesce next */
    uint32_t const size = the_size + next_size;
    _Heap_Block_replace( next_block, the_block );
    the_block->size = size | HEAP_PREV_USED;
   4b5b6:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
   4b5ba:	d7ab 0030      	addl %d3,%a3@(48)                                 	<== NOT EXECUTED
  stats->frees += 1;
   4b5be:	52ab 0050      	addql #1,%a3@(80)                                 	<== NOT EXECUTED
    stats->free_blocks += 1;
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
   4b5c2:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   4b5c6:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
  block->prev = prev;
   4b5ca:	2548 000c      	movel %a0,%a2@(12)                                	<== NOT EXECUTED
  next->prev = prev->next = block;
   4b5ce:	214a 0008      	movel %a2,%a0@(8)                                 	<== NOT EXECUTED
   4b5d2:	234a 000c      	movel %a2,%a1@(12)                                	<== NOT EXECUTED
   4b5d6:	60b0           	bras 4b588 <_Heap_Free+0xc0>                      	<== 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;
   4b5d8:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4b5da:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
)
{
  Heap_Block *prev = prev_block;
  Heap_Block *block = the_block;

  Heap_Block *next = prev->next;
   4b5dc:	206b 0008      	moveal %a3@(8),%a0                                	<== NOT EXECUTED
   4b5e0:	2542 0004      	movel %d2,%a2@(4)                                 	<== NOT EXECUTED
    next_block->size &= ~HEAP_PREV_USED;
   4b5e4:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   4b5e6:	c1ac 0004      	andl %d0,%a4@(4)                                  	<== NOT EXECUTED
    next_block->prev_size = the_size;
   4b5ea:	2883           	movel %d3,%a4@                                    	<== NOT EXECUTED

    stats->free_blocks += 1;
   4b5ec:	202b 0038      	movel %a3@(56),%d0                                	<== NOT EXECUTED
  block->next  = next;
   4b5f0:	2548 0008      	movel %a0,%a2@(8)                                 	<== NOT EXECUTED
   4b5f4:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
  block->prev  = prev;
   4b5f6:	254b 000c      	movel %a3,%a2@(12)                                	<== NOT EXECUTED
  next->prev = prev->next = block;
   4b5fa:	274a 0008      	movel %a2,%a3@(8)                                 	<== NOT EXECUTED
   4b5fe:	214a 000c      	movel %a2,%a0@(12)                                	<== NOT EXECUTED
   4b602:	2740 0038      	movel %d0,%a3@(56)                                	<== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks )
   4b606:	b0ab 003c      	cmpl %a3@(60),%d0                                 	<== NOT EXECUTED
   4b60a:	6300 ff6e      	blsw 4b57a <_Heap_Free+0xb2>                      	<== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
   4b60e:	d7ab 0030      	addl %d3,%a3@(48)                                 	<== NOT EXECUTED
  stats->frees += 1;
   4b612:	52ab 0050      	addql #1,%a3@(80)                                 	<== NOT EXECUTED
    stats->free_blocks += 1;
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
   4b616:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
    next_block->size &= ~HEAP_PREV_USED;
    next_block->prev_size = the_size;

    stats->free_blocks += 1;
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
   4b61a:	2740 003c      	movel %d0,%a3@(60)                                	<== NOT EXECUTED
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
  stats->frees += 1;
   4b61e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4b620:	6000 ff66      	braw 4b588 <_Heap_Free+0xc0>                      	<== 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;
   4b624:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   4b626:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
      prev_block->size = size | HEAP_PREV_USED;
   4b628:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
      next_block->size &= ~HEAP_PREV_USED;
      next_block->prev_size = size;
   4b62a:	2880           	movel %d0,%a4@                                    	<== NOT EXECUTED
      _HAssert(!_Heap_Is_prev_used( next_block));
      next_block->prev_size = size;
    }
    else {                      /* coalesce prev */
      uint32_t const size = the_size + prev_size;
      prev_block->size = size | HEAP_PREV_USED;
   4b62c:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
      next_block->size &= ~HEAP_PREV_USED;
   4b62e:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
      _HAssert(!_Heap_Is_prev_used( next_block));
      next_block->prev_size = size;
    }
    else {                      /* coalesce prev */
      uint32_t const size = the_size + prev_size;
      prev_block->size = size | HEAP_PREV_USED;
   4b630:	2542 0004      	movel %d2,%a2@(4)                                 	<== NOT EXECUTED
      next_block->size &= ~HEAP_PREV_USED;
   4b634:	c1ac 0004      	andl %d0,%a4@(4)                                  	<== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
   4b638:	d7ab 0030      	addl %d3,%a3@(48)                                 	<== NOT EXECUTED
  stats->frees += 1;
   4b63c:	52ab 0050      	addql #1,%a3@(80)                                 	<== NOT EXECUTED
    stats->free_blocks += 1;
    if ( stats->max_free_blocks < stats->free_blocks )
      stats->max_free_blocks = stats->free_blocks;
  }

  stats->used_blocks -= 1;
   4b640:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
  stats->free_size += the_size;
  stats->frees += 1;
   4b644:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4b646:	6000 ff40      	braw 4b588 <_Heap_Free+0xc0>                      	<== NOT EXECUTED
	...

000636c4 <_Heap_Get_free_information>:

void _Heap_Get_free_information(
  Heap_Control        *the_heap,
  Heap_Information    *info
)
{
   636c4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   636c8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   636ca:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   636ce:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   636d2:	226a 0008      	moveal %a2@(8),%a1                                	<== NOT EXECUTED
  Heap_Block *the_block;
  Heap_Block *const tail = _Heap_Tail(the_heap);

  info->number = 0;
   636d6:	4290           	clrl %a0@                                         	<== NOT EXECUTED
  info->largest = 0;
   636d8:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  info->total = 0;
   636dc:	42a8 0008      	clrl %a0@(8)                                      	<== NOT EXECUTED

  for(the_block = _Heap_First(the_heap);
      the_block != tail;
   636e0:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   636e2:	671e           	beqs 63702 <_Heap_Get_free_information+0x3e>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   636e4:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   636e6:	c0a9 0004      	andl %a1@(4),%d0                                  	<== 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++;
   636ea:	5290           	addql #1,%a0@                                     	<== NOT EXECUTED
    info->total += the_size;
   636ec:	d1a8 0008      	addl %d0,%a0@(8)                                  	<== NOT EXECUTED
    if ( info->largest < the_size )
   636f0:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   636f4:	6304           	blss 636fa <_Heap_Get_free_information+0x36>      	<== NOT EXECUTED
        info->largest = the_size;
   636f6:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
  info->largest = 0;
  info->total = 0;

  for(the_block = _Heap_First(the_heap);
      the_block != tail;
      the_block = the_block->next)
   636fa:	2269 0008      	moveal %a1@(8),%a1                                	<== NOT EXECUTED
  info->number = 0;
  info->largest = 0;
  info->total = 0;

  for(the_block = _Heap_First(the_heap);
      the_block != tail;
   636fe:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   63700:	66e2           	bnes 636e4 <_Heap_Get_free_information+0x20>      	<== NOT EXECUTED
    info->number++;
    info->total += the_size;
    if ( info->largest < the_size )
        info->largest = the_size;
  }
}
   63702:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   63704:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   63706:	4e75           	rts

0006dd74 <_Heap_Get_information>:

Heap_Get_information_status _Heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
   6dd74:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   6dd78:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   6dd7c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Heap_Block *the_block = the_heap->start;
  Heap_Block *const end = the_heap->final;
   6dd7e:	2428 0024      	movel %a0@(36),%d2                                	<== NOT EXECUTED

Heap_Get_information_status _Heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
   6dd82:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
  Heap_Block *the_block = the_heap->start;
   6dd86:	2068 0020      	moveal %a0@(32),%a0                               	<== NOT EXECUTED
  Heap_Block *const end = the_heap->final;

  _HAssert(the_block->prev_size == HEAP_PREV_USED);
  _HAssert(_Heap_Is_prev_used(the_block));

  the_info->Free.number  = 0;
   6dd8a:	4291           	clrl %a1@                                         	<== NOT EXECUTED
  the_info->Free.total   = 0;
   6dd8c:	42a9 0008      	clrl %a1@(8)                                      	<== NOT EXECUTED
  the_info->Free.largest = 0;
   6dd90:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  the_info->Used.number  = 0;
   6dd94:	42a9 000c      	clrl %a1@(12)                                     	<== NOT EXECUTED
  the_info->Used.total   = 0;
   6dd98:	42a9 0014      	clrl %a1@(20)                                     	<== NOT EXECUTED
  the_info->Used.largest = 0;
   6dd9c:	42a9 0010      	clrl %a1@(16)                                     	<== NOT EXECUTED

  while ( the_block != end ) {
   6dda0:	b488           	cmpl %a0,%d2                                      	<== NOT EXECUTED
   6dda2:	672a           	beqs 6ddce <_Heap_Get_information+0x5a>           	<== NOT EXECUTED
   6dda4:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   6dda8:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   6ddaa:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   6ddac:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   6ddae:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
    uint32_t const the_size = _Heap_Block_size(the_block);
    Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);

    if ( _Heap_Is_prev_used(next_block) ) {
   6ddb2:	0801 0000      	btst #0,%d1                                       	<== NOT EXECUTED
   6ddb6:	6722           	beqs 6ddda <_Heap_Get_information+0x66>           	<== NOT EXECUTED
      the_info->Used.number++;
   6ddb8:	52a9 000c      	addql #1,%a1@(12)                                 	<== NOT EXECUTED
      the_info->Used.total += the_size;
   6ddbc:	d1a9 0014      	addl %d0,%a1@(20)                                 	<== NOT EXECUTED
      if ( the_info->Used.largest < the_size )
   6ddc0:	b0a9 0010      	cmpl %a1@(16),%d0                                 	<== NOT EXECUTED
   6ddc4:	6304           	blss 6ddca <_Heap_Get_information+0x56>           	<== NOT EXECUTED
        the_info->Used.largest = the_size;
   6ddc6:	2340 0010      	movel %d0,%a1@(16)                                	<== 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 ) {
   6ddca:	b1c2           	cmpal %d2,%a0                                     	<== NOT EXECUTED
   6ddcc:	66da           	bnes 6dda8 <_Heap_Get_information+0x34>           	<== NOT EXECUTED
     "used" as client never allocated it. Make 'Used.total' contain this
     blocks' overhead though. */
  the_info->Used.total += HEAP_OVERHEAD;

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   6ddce:	241f           	movel %sp@+,%d2                                   	<== 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;
   6ddd0:	50a9 0014      	addql #8,%a1@(20)                                 	<== NOT EXECUTED

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   6ddd4:	4e5e           	unlk %fp                                          	<== 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;
   6ddd6:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   6ddd8:	4e75           	rts                                               	<== NOT EXECUTED
      the_info->Used.number++;
      the_info->Used.total += the_size;
      if ( the_info->Used.largest < the_size )
        the_info->Used.largest = the_size;
    } else {
      the_info->Free.number++;
   6ddda:	5291           	addql #1,%a1@                                     	<== NOT EXECUTED
      the_info->Free.total += the_size;
   6dddc:	d1a9 0008      	addl %d0,%a1@(8)                                  	<== NOT EXECUTED
      if ( the_info->Free.largest < the_size )
   6dde0:	b0a9 0004      	cmpl %a1@(4),%d0                                  	<== NOT EXECUTED
   6dde4:	6304           	blss 6ddea <_Heap_Get_information+0x76>           	<== NOT EXECUTED
        the_info->Free.largest = the_size;
   6dde6:	2340 0004      	movel %d0,%a1@(4)                                 	<== NOT EXECUTED
      if ( the_size != next_block->prev_size )
   6ddea:	b090           	cmpl %a0@,%d0                                     	<== NOT EXECUTED
   6ddec:	67dc           	beqs 6ddca <_Heap_Get_information+0x56>           	<== NOT EXECUTED
     "used" as client never allocated it. Make 'Used.total' contain this
     blocks' overhead though. */
  the_info->Used.total += HEAP_OVERHEAD;

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   6ddee:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   6ddf0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    } else {
      the_info->Free.number++;
      the_info->Free.total += the_size;
      if ( the_info->Free.largest < the_size )
        the_info->Free.largest = the_size;
      if ( the_size != next_block->prev_size )
   6ddf2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
     "used" as client never allocated it. Make 'Used.total' contain this
     blocks' overhead though. */
  the_info->Used.total += HEAP_OVERHEAD;

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   6ddf4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046c48 <_Heap_Initialize>:
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t               size,
  uint32_t             page_size
)
{
   46c48:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   46c4c:	48d7 047c      	moveml %d2-%d6/%a2,%sp@                           	<== NOT EXECUTED
   46c50:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   46c54:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   46c58:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
   46c5c:	242e 0014      	movel %fp@(20),%d2                                	<== 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)
   46c60:	6600 00ec      	bnew 46d4e <_Heap_Initialize+0x106>               	<== NOT EXECUTED
   46c64:	143c 0004      	moveb #4,%d2                                      	<== NOT EXECUTED
   46c68:	4283           	clrl %d3                                          	<== 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;
   46c6a:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   46c6c:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  uint32_t a = alignment;
  _H_uptr_t r = v % a;
   46c6e:	2c00           	movel %d0,%d6                                     	<== NOT EXECUTED
   46c70:	4c42 6001      	remul %d2,%d1,%d6                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   46c74:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   46c76:	6704           	beqs 46c7c <_Heap_Initialize+0x34>                	<== NOT EXECUTED
   46c78:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
   46c7a:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
  _Heap_Align_up_uptr ( &aligned_start, page_size );
  aligned_start -= HEAP_BLOCK_USER_OFFSET;
   46c7c:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   46c7e:	5189           	subql #8,%a1                                      	<== NOT EXECUTED
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
  *value = r ? v - r + a : v;
   46c80:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   46c82:	6600 00bc      	bnew 46d40 <_Heap_Initialize+0xf8>                	<== NOT EXECUTED
   46c86:	7210           	moveq #16,%d1                                     	<== 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);
   46c88:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
   46c8a:	9085           	subl %d5,%d0                                      	<== NOT EXECUTED
   46c8c:	d089           	addl %a1,%d0                                      	<== NOT EXECUTED
   46c8e:	2541 0014      	movel %d1,%a2@(20)                                	<== NOT EXECUTED
  if ( size < overhead )
   46c92:	b880           	cmpl %d0,%d4                                      	<== NOT EXECUTED
   46c94:	6500 009e      	bcsw 46d34 <_Heap_Initialize+0xec>                	<== NOT EXECUTED
    return 0;   /* Too small area for the heap */
  the_size = size - overhead;
   46c98:	2204           	movel %d4,%d1                                     	<== NOT EXECUTED
   46c9a:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   46c9c:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   46c9e:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
   46ca0:	4c42 3001      	remul %d2,%d1,%d3                                 	<== NOT EXECUTED
   46ca4:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   46ca6:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  _Heap_Align_down ( &the_size, page_size );
  if ( the_size == 0 )
   46ca8:	6700 008a      	beqw 46d34 <_Heap_Initialize+0xec>                	<== NOT EXECUTED
    return 0;   /* Too small area for the heap */

  the_heap->page_size = page_size;
   46cac:	2542 0010      	movel %d2,%a2@(16)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
  void       *base,
  uint32_t    offset
)
{
  return (void *)((char *)base + offset);
   46cb0:	41f1 0800      	lea %a1@(00000000,%d0:l),%a0                      	<== NOT EXECUTED
  the_heap->end = starting_address + size;

  the_block = (Heap_Block *) aligned_start;

  the_block->prev_size = page_size;
  the_block->size = the_size | HEAP_PREV_USED;
   46cb4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46cb6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   46cb8:	2340 0004      	movel %d0,%a1@(4)                                 	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   46cbc:	2039 0005 7f00 	movel 57f00 <instance>,%d0                        	<== NOT EXECUTED
  the_heap->begin = starting_address;
  the_heap->end = starting_address + size;

  the_block = (Heap_Block *) aligned_start;

  the_block->prev_size = page_size;
   46cc2:	2282           	movel %d2,%a1@                                    	<== NOT EXECUTED
  _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 */
  the_block->prev_size = the_size;   /* Previous block is free */
  the_block->size = page_size;
   46cc4:	2142 0004      	movel %d2,%a0@(4)                                 	<== NOT EXECUTED

  stats->size = size;
  stats->free_size = the_size;
  stats->min_free_size = the_size;
  stats->free_blocks = 1;
   46cc8:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
  _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 */
  the_block->prev_size = the_size;   /* Previous block is free */
   46cca:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  the_block->size = page_size;

  stats->size = size;
  stats->free_size = the_size;
  stats->min_free_size = the_size;
  stats->free_blocks = 1;
   46ccc:	2542 0038      	movel %d2,%a2@(56)                                	<== NOT EXECUTED
  stats->max_free_blocks = 1;
   46cd0:	2542 003c      	movel %d2,%a2@(60)                                	<== NOT EXECUTED
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
   46cd4:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   46cd6:	5982           	subql #4,%d2                                      	<== NOT EXECUTED
  the_block = _Heap_Block_at( the_block, the_size );
  the_heap->final = the_block;       /* Permanent final block of the heap */
  the_block->prev_size = the_size;   /* Previous block is free */
  the_block->size = page_size;

  stats->size = size;
   46cd8:	2544 002c      	movel %d4,%a2@(44)                                	<== NOT EXECUTED
  if ( the_size == 0 )
    return 0;   /* Too small area for the heap */

  the_heap->page_size = page_size;
  the_heap->begin = starting_address;
  the_heap->end = starting_address + size;
   46cdc:	d885           	addl %d5,%d4                                      	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   46cde:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   46ce2:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
  the_heap->final = the_block;       /* Permanent final block of the heap */
  the_block->prev_size = the_size;   /* Previous block is free */
  the_block->size = page_size;

  stats->size = size;
  stats->free_size = the_size;
   46ce4:	2541 0030      	movel %d1,%a2@(48)                                	<== NOT EXECUTED
  stats->min_free_size = the_size;
   46ce8:	2541 0034      	movel %d1,%a2@(52)                                	<== NOT EXECUTED
  stats->free_blocks = 1;
  stats->max_free_blocks = 1;
  stats->used_blocks = 0;
   46cec:	42aa 0040      	clrl %a2@(64)                                     	<== NOT EXECUTED
  stats->max_search = 0;
   46cf0:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
  stats->allocs = 0;
   46cf4:	42aa 0048      	clrl %a2@(72)                                     	<== NOT EXECUTED
  stats->searches = 0;
   46cf8:	42aa 004c      	clrl %a2@(76)                                     	<== NOT EXECUTED
  stats->frees = 0;
   46cfc:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  stats->resizes = 0;
   46d00:	42aa 0054      	clrl %a2@(84)                                     	<== NOT EXECUTED

  the_block = (Heap_Block *) aligned_start;

  the_block->prev_size = page_size;
  the_block->size = the_size | HEAP_PREV_USED;
  the_block->next = _Heap_Tail( the_heap );
   46d04:	234a 0008      	movel %a2,%a1@(8)                                 	<== NOT EXECUTED
  the_block->prev = _Heap_Head( the_heap );
   46d08:	234a 000c      	movel %a2,%a1@(12)                                	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   46d0c:	23c0 0005 7f00 	movel %d0,57f00 <instance>                        	<== NOT EXECUTED

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
}
   46d12:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
  if ( the_size == 0 )
    return 0;   /* Too small area for the heap */

  the_heap->page_size = page_size;
  the_heap->begin = starting_address;
  the_heap->end = starting_address + size;
   46d14:	2544 001c      	movel %d4,%a2@(28)                                	<== NOT EXECUTED
  _Heap_Align_down ( &the_size, page_size );
  if ( the_size == 0 )
    return 0;   /* Too small area for the heap */

  the_heap->page_size = page_size;
  the_heap->begin = starting_address;
   46d18:	2545 0018      	movel %d5,%a2@(24)                                	<== NOT EXECUTED

  the_block->prev_size = page_size;
  the_block->size = the_size | HEAP_PREV_USED;
  the_block->next = _Heap_Tail( the_heap );
  the_block->prev = _Heap_Head( the_heap );
  _Heap_Head(the_heap)->next = the_block;
   46d1c:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
  _Heap_Tail(the_heap)->prev = the_block;
   46d20:	2549 000c      	movel %a1,%a2@(12)                                	<== NOT EXECUTED
  the_heap->start = the_block;
   46d24:	2549 0020      	movel %a1,%a2@(32)                                	<== 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 */
   46d28:	2548 0024      	movel %a0,%a2@(36)                                	<== NOT EXECUTED
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
}
   46d2c:	4cd7 047c      	moveml %sp@,%d2-%d6/%a2                           	<== NOT EXECUTED
   46d30:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46d32:	4e75           	rts                                               	<== NOT EXECUTED
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
   46d34:	4282           	clrl %d2                                          	<== NOT EXECUTED
}
   46d36:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46d38:	4cd7 047c      	moveml %sp@,%d2-%d6/%a2                           	<== NOT EXECUTED
   46d3c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46d3e:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
  *value = r ? v - r + a : v;
   46d40:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   46d42:	0681 0000 0010 	addil #16,%d1                                     	<== NOT EXECUTED
   46d48:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
   46d4a:	6000 ff3c      	braw 46c88 <_Heap_Initialize+0x40>                	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   46d4e:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   46d50:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   46d52:	670e           	beqs 46d62 <_Heap_Initialize+0x11a>               	<== NOT EXECUTED
   46d54:	5882           	addql #4,%d2                                      	<== NOT EXECUTED
   46d56:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   46d58:	7010           	moveq #16,%d0                                     	<== NOT EXECUTED
   46d5a:	4c42 0003      	remul %d2,%d3,%d0                                 	<== NOT EXECUTED
   46d5e:	6000 ff0a      	braw 46c6a <_Heap_Initialize+0x22>                	<== NOT EXECUTED
   46d62:	103c 0010      	moveb #16,%d0                                     	<== NOT EXECUTED
   46d66:	4c42 0003      	remul %d2,%d3,%d0                                 	<== NOT EXECUTED
   46d6a:	6000 fefe      	braw 46c6a <_Heap_Initialize+0x22>                	<== NOT EXECUTED

00055188 <_Heap_Resize_block>:
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   55188:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
   5518c:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   55190:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   55194:	286e 0014      	moveal %fp@(20),%a4                               	<== 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;
   55198:	282b 0014      	movel %a3@(20),%d4                                	<== NOT EXECUTED
  uint32_t const page_size = the_heap->page_size;
   5519c:	262b 0010      	movel %a3@(16),%d3                                	<== NOT EXECUTED
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   551a0:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  uint32_t   prev_used_flag;
  Heap_Statistics *const stats = &the_heap->stats;
  uint32_t const min_block_size = the_heap->min_block_size;
  uint32_t const page_size = the_heap->page_size;

  *old_mem_size = 0;
   551a4:	4294           	clrl %a4@                                         	<== NOT EXECUTED
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   551a6:	2a6e 0018      	moveal %fp@(24),%a5                               	<== NOT EXECUTED
  /* The address passed could be greater than the block address plus
   * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
   * pointers. To get rid of this offset we need to align the address down
   * to the nearest 'page_size' boundary. */
  _Heap_Align_down_uptr ( &addr, the_heap->page_size );
  *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
   551aa:	2442           	moveal %d2,%a2                                    	<== NOT EXECUTED
  Heap_Statistics *const stats = &the_heap->stats;
  uint32_t const min_block_size = the_heap->min_block_size;
  uint32_t const page_size = the_heap->page_size;

  *old_mem_size = 0;
  *avail_mem_size = 0;
   551ac:	4295           	clrl %a5@                                         	<== NOT EXECUTED
   551ae:	2a02           	movel %d2,%d5                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in (
  Heap_Control *the_heap,
  Heap_Block   *the_block
)
{
  return _Addresses_Is_in_range( the_block, the_heap->start, the_heap->final );
   551b0:	206b 0024      	moveal %a3@(36),%a0                               	<== NOT EXECUTED
   551b4:	222b 0020      	movel %a3@(32),%d1                                	<== NOT EXECUTED
  /* The address passed could be greater than the block address plus
   * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
   * pointers. To get rid of this offset we need to align the address down
   * to the nearest 'page_size' boundary. */
  _Heap_Align_down_uptr ( &addr, the_heap->page_size );
  *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
   551b8:	518a           	subql #8,%a2                                      	<== NOT EXECUTED
   551ba:	4c6b 5000 0010 	remul %a3@(16),%d0,%d5                            	<== NOT EXECUTED
   551c0:	95c0           	subal %d0,%a2                                     	<== NOT EXECUTED
   551c2:	b28a           	cmpl %a2,%d1                                      	<== NOT EXECUTED
   551c4:	6204           	bhis 551ca <_Heap_Resize_block+0x42>              	<== NOT EXECUTED
   551c6:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   551c8:	640c           	bccs 551d6 <_Heap_Resize_block+0x4e>              	<== NOT EXECUTED
    }
  }

  ++stats->resizes;
  return HEAP_RESIZE_SUCCESSFUL;
}
   551ca:	4cee 3cfc ffcc 	moveml %fp@(-52),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   551d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      }
    }
  }

  ++stats->resizes;
  return HEAP_RESIZE_SUCCESSFUL;
   551d2:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
}
   551d4:	4e75           	rts                                               	<== 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;
   551d6:	2c2a 0004      	movel %a2@(4),%d6                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   551da:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   551dc:	c086           	andl %d6,%d0                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   551de:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   551e0:	d3ca           	addal %a2,%a1                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   551e2:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   551e6:	2d49 fff4      	movel %a1,%fp@(-12)                               	<== NOT EXECUTED
   551ea:	b3c1           	cmpal %d1,%a1                                     	<== NOT EXECUTED
   551ec:	65dc           	bcss 551ca <_Heap_Resize_block+0x42>              	<== NOT EXECUTED
   551ee:	b3c8           	cmpal %a0,%a1                                     	<== NOT EXECUTED
   551f0:	62d8           	bhis 551ca <_Heap_Resize_block+0x42>              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   551f2:	2229 0004      	movel %a1@(4),%d1                                 	<== 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) ||
   551f6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   551f8:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   551fa:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   551fc:	67cc           	beqs 551ca <_Heap_Resize_block+0x42>              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   551fe:	7efe           	moveq #-2,%d7                                     	<== NOT EXECUTED
   55200:	ce81           	andl %d1,%d7                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   55202:	d3c7           	addal %d7,%a1                                     	<== NOT EXECUTED
   55204:	2d49 fff8      	movel %a1,%fp@(-8)                                	<== 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) ||
   55208:	b1ee fff4      	cmpal %fp@(-12),%a0                               	<== NOT EXECUTED
   5520c:	6700 0100      	beqw 5530e <_Heap_Resize_block+0x186>             	<== NOT EXECUTED
   55210:	206e fff8      	moveal %fp@(-8),%a0                               	<== NOT EXECUTED
   55214:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED
   55216:	caa8 0004      	andl %a0@(4),%d5                                  	<== 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)
   5521a:	206e fff4      	moveal %fp@(-12),%a0                              	<== NOT EXECUTED
   5521e:	91c2           	subal %d2,%a0                                     	<== NOT EXECUTED
   55220:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   55222:	5880           	addql #4,%d0                                      	<== 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;
   55224:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED

  /* See _Heap_Size_of_user_area() source for explanations */
  old_user_size = _Addresses_Subtract(next_block, starting_address)
    + HEAP_BLOCK_HEADER_OFFSET;

  *old_mem_size = old_user_size;
   55226:	2880           	movel %d0,%a4@                                    	<== 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;
   55228:	cc81           	andl %d1,%d6                                      	<== NOT EXECUTED
  old_user_size = _Addresses_Subtract(next_block, starting_address)
    + HEAP_BLOCK_HEADER_OFFSET;

  *old_mem_size = old_user_size;

  if (size > old_user_size) {
   5522a:	b0ae 0010      	cmpl %fp@(16),%d0                                 	<== NOT EXECUTED
   5522e:	6432           	bccs 55262 <_Heap_Resize_block+0xda>              	<== 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 */
   55230:	4a05           	tstb %d5                                          	<== NOT EXECUTED
   55232:	6622           	bnes 55256 <_Heap_Resize_block+0xce>              	<== NOT EXECUTED
      return HEAP_RESIZE_UNSATISFIED;
    else {
      uint32_t add_block_size = size - old_user_size;
   55234:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   55238:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   5523a:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   5523c:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   5523e:	4c43 2001      	remul %d3,%d1,%d2                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   55242:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   55244:	6704           	beqs 5524a <_Heap_Resize_block+0xc2>              	<== NOT EXECUTED
   55246:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED
   55248:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   5524a:	b880           	cmpl %d0,%d4                                      	<== NOT EXECUTED
   5524c:	6200 008e      	bhiw 552dc <_Heap_Resize_block+0x154>             	<== 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)
   55250:	b087           	cmpl %d7,%d0                                      	<== NOT EXECUTED
   55252:	6300 0090      	blsw 552e4 <_Heap_Resize_block+0x15c>             	<== NOT EXECUTED
    }
  }

  ++stats->resizes;
  return HEAP_RESIZE_SUCCESSFUL;
}
   55256:	4cee 3cfc ffcc 	moveml %fp@(-52),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   5525c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      }
    }
  }

  ++stats->resizes;
  return HEAP_RESIZE_SUCCESSFUL;
   5525e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
}
   55260:	4e75           	rts                                               	<== NOT EXECUTED
      --stats->used_blocks;
    }
  } else {

    /* Calculate how much memory we could free */
    uint32_t free_block_size = old_user_size - size;
   55262:	90ae 0010      	subl %fp@(16),%d0                                 	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   55266:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   55268:	4c43 2001      	remul %d3,%d1,%d2                                 	<== NOT EXECUTED
   5526c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5526e:	9481           	subl %d1,%d2                                      	<== NOT EXECUTED
    _Heap_Align_down(&free_block_size, page_size);

    if (free_block_size > 0) {
   55270:	675a           	beqs 552cc <_Heap_Resize_block+0x144>             	<== 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;
   55272:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   55276:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED

      if (new_block_size < min_block_size) {
   55278:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   5527a:	640a           	bccs 55286 <_Heap_Resize_block+0xfe>              	<== NOT EXECUTED
        uint32_t delta = min_block_size - new_block_size;
   5527c:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   5527e:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
        _HAssert(free_block_size >= delta);
        free_block_size -= delta;
   55280:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
        if (free_block_size == 0) {
   55282:	6748           	beqs 552cc <_Heap_Resize_block+0x144>             	<== NOT EXECUTED
          ++stats->resizes;
          return HEAP_RESIZE_SUCCESSFUL;
        }
        new_block_size += delta;
   55284:	d280           	addl %d0,%d1                                      	<== 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) {
   55286:	4a05           	tstb %d5                                          	<== NOT EXECUTED
   55288:	6600 008a      	bnew 55314 <_Heap_Resize_block+0x18c>             	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   5528c:	41f2 1800      	lea %a2@(00000000,%d1:l),%a0                      	<== NOT EXECUTED
        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;
        _HAssert(_Heap_Is_block_in(the_heap, next_next_block));
        the_block->size = new_block_size | prev_used_flag;
   55290:	8286           	orl %d6,%d1                                       	<== NOT EXECUTED
        new_next_block->size = new_next_block_size | HEAP_PREV_USED;
        next_next_block->prev_size = new_next_block_size;
   55292:	226e fff8      	moveal %fp@(-8),%a1                               	<== NOT EXECUTED
        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;
        _HAssert(_Heap_Is_block_in(the_heap, next_next_block));
        the_block->size = new_block_size | prev_used_flag;
   55296:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
   5529a:	286e fff4      	moveal %fp@(-12),%a4                              	<== NOT EXECUTED
      if (!next_is_used) {
        /* 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;
   5529e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   552a0:	d087           	addl %d7,%d0                                      	<== NOT EXECUTED
        _HAssert(_Heap_Is_block_in(the_heap, next_next_block));
        the_block->size = new_block_size | prev_used_flag;
        new_next_block->size = new_next_block_size | HEAP_PREV_USED;
   552a2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
        next_next_block->prev_size = new_next_block_size;
   552a4:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
          _Heap_Block_at(the_block, new_block_size);
        uint32_t const new_next_block_size =
          next_block_size + free_block_size;
        _HAssert(_Heap_Is_block_in(the_heap, next_next_block));
        the_block->size = new_block_size | prev_used_flag;
        new_next_block->size = new_next_block_size | HEAP_PREV_USED;
   552a6:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   552a8:	246c 000c      	moveal %a4@(12),%a2                               	<== NOT EXECUTED
  Heap_Block *old_block,
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
   552ac:	226c 0008      	moveal %a4@(8),%a1                                	<== NOT EXECUTED
   552b0:	2141 0004      	movel %d1,%a0@(4)                                 	<== NOT EXECUTED
        next_next_block->prev_size = new_next_block_size;
        _Heap_Block_replace(next_block, new_next_block);
        the_heap->stats.free_size += free_block_size;
   552b4:	d5ab 0030      	addl %d2,%a3@(48)                                 	<== NOT EXECUTED
        *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
   552b8:	5980           	subql #4,%d0                                      	<== NOT EXECUTED
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   552ba:	2149 0008      	movel %a1,%a0@(8)                                 	<== NOT EXECUTED
  block->prev = prev;
   552be:	214a 000c      	movel %a2,%a0@(12)                                	<== NOT EXECUTED
   552c2:	2a80           	movel %d0,%a5@                                    	<== NOT EXECUTED
  next->prev = prev->next = block;
   552c4:	2348 000c      	movel %a0,%a1@(12)                                	<== NOT EXECUTED
   552c8:	2548 0008      	movel %a0,%a2@(8)                                 	<== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
      }
    }
  }

  ++stats->resizes;
   552cc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   552ce:	52ab 0054      	addql #1,%a3@(84)                                 	<== NOT EXECUTED
  return HEAP_RESIZE_SUCCESSFUL;
}
   552d2:	4cee 3cfc ffcc 	moveml %fp@(-52),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   552d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   552da:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
  *value = r ? v - r + a : v;
   552dc:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
    else {
      uint32_t add_block_size = size - old_user_size;
      _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)
   552de:	b087           	cmpl %d7,%d0                                      	<== NOT EXECUTED
   552e0:	6200 ff74      	bhiw 55256 <_Heap_Resize_block+0xce>              	<== NOT EXECUTED
        return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
      add_block_size =
   552e4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   552e6:	2f2e fff4      	movel %fp@(-12),%sp@-                             	<== NOT EXECUTED
   552ea:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   552ec:	4eb9 0004 6daa 	jsr 46daa <_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;
   552f2:	d0ae fffc      	addl %fp@(-4),%d0                                 	<== NOT EXECUTED
   552f6:	8086           	orl %d6,%d0                                       	<== NOT EXECUTED
   552f8:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
      --stats->used_blocks;
   552fc:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
      }
    }
  }

  ++stats->resizes;
   55300:	52ab 0054      	addql #1,%a3@(84)                                 	<== NOT EXECUTED
        return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
      add_block_size =
        _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;
      --stats->used_blocks;
   55304:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
      }
    }
  }

  ++stats->resizes;
   5530a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5530c:	60c4           	bras 552d2 <_Heap_Resize_block+0x14a>             	<== 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) ||
   5530e:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED
   55310:	6000 ff08      	braw 5521a <_Heap_Resize_block+0x92>              	<== NOT EXECUTED
        next_next_block->prev_size = new_next_block_size;
        _Heap_Block_replace(next_block, new_next_block);
        the_heap->stats.free_size += free_block_size;
        *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;

      } else if (free_block_size >= min_block_size) {
   55314:	b484           	cmpl %d4,%d2                                      	<== NOT EXECUTED
   55316:	65b4           	bcss 552cc <_Heap_Resize_block+0x144>             	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   55318:	41f2 1800      	lea %a2@(00000000,%d1:l),%a0                      	<== NOT EXECUTED
        /* Split the block into 2 used  parts, then free the second one. */
        the_block->size = new_block_size | prev_used_flag;
   5531c:	8286           	orl %d6,%d1                                       	<== NOT EXECUTED
   5531e:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
        next_block = _Heap_Block_at(the_block, new_block_size);
        next_block->size = free_block_size | HEAP_PREV_USED;
   55322:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        ++stats->used_blocks; /* We have created used block */
        --stats->frees;       /* Don't count next call in stats */
        _Heap_Free(the_heap, _Heap_User_area(next_block));
   55324:	4868 0008      	pea %a0@(8)                                       	<== NOT EXECUTED

      } else if (free_block_size >= min_block_size) {
        /* Split the block into 2 used  parts, then free the second one. */
        the_block->size = new_block_size | prev_used_flag;
        next_block = _Heap_Block_at(the_block, new_block_size);
        next_block->size = free_block_size | HEAP_PREV_USED;
   55328:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
        ++stats->used_blocks; /* We have created used block */
        --stats->frees;       /* Don't count next call in stats */
        _Heap_Free(the_heap, _Heap_User_area(next_block));
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
   5532a:	5982           	subql #4,%d2                                      	<== NOT EXECUTED

      } else if (free_block_size >= min_block_size) {
        /* Split the block into 2 used  parts, then free the second one. */
        the_block->size = new_block_size | prev_used_flag;
        next_block = _Heap_Block_at(the_block, new_block_size);
        next_block->size = free_block_size | HEAP_PREV_USED;
   5532c:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
        ++stats->used_blocks; /* We have created used block */
   55330:	52ab 0040      	addql #1,%a3@(64)                                 	<== NOT EXECUTED
        --stats->frees;       /* Don't count next call in stats */
   55334:	53ab 0050      	subql #1,%a3@(80)                                 	<== NOT EXECUTED
        _Heap_Free(the_heap, _Heap_User_area(next_block));
   55338:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5533a:	4eb9 0004 b4c8 	jsr 4b4c8 <_Heap_Free>                            	<== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
   55340:	2a82           	movel %d2,%a5@                                    	<== NOT EXECUTED
      }
    }
  }

  ++stats->resizes;
   55342:	52ab 0054      	addql #1,%a3@(84)                                 	<== NOT EXECUTED
        next_block = _Heap_Block_at(the_block, new_block_size);
        next_block->size = free_block_size | HEAP_PREV_USED;
        ++stats->used_blocks; /* We have created used block */
        --stats->frees;       /* Don't count next call in stats */
        _Heap_Free(the_heap, _Heap_User_area(next_block));
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
   55346:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      }
    }
  }

  ++stats->resizes;
   55348:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5534a:	6086           	bras 552d2 <_Heap_Resize_block+0x14a>             	<== NOT EXECUTED

0005534c <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t              *size
)
{
   5534c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   55350:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   55352:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   55356:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   55358:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Heap_Block        *the_block;
  Heap_Block        *next_block;
  uint32_t           the_size;

  if ( !_Addresses_Is_in_range(
   5535c:	2268 0024      	moveal %a0@(36),%a1                               	<== NOT EXECUTED
   55360:	2228 0020      	movel %a0@(32),%d1                                	<== NOT EXECUTED
   55364:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   55366:	6504           	bcss 5536c <_Heap_Size_of_user_area+0x20>         	<== NOT EXECUTED
   55368:	b489           	cmpl %a1,%d2                                      	<== NOT EXECUTED
   5536a:	630a           	blss 55376 <_Heap_Size_of_user_area+0x2a>         	<== NOT EXECUTED

  *size = _Addresses_Subtract ( next_block, starting_address )
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
}
   5536c:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   5536e:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   55370:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
     area of 'the_block'. */

  *size = _Addresses_Subtract ( next_block, starting_address )
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
   55372:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   55374:	4e75           	rts                                               	<== NOT EXECUTED
  /* The address passed could be greater than the block address plus
   * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
   * pointers. To get rid of this offset we need to align the address down
   * to the nearest 'page_size' boundary. */
  _Heap_Align_down_uptr ( &addr, the_heap->page_size );
  *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
   55376:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   55378:	4c68 3000 0010 	remul %a0@(16),%d0,%d3                            	<== NOT EXECUTED
   5537e:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   55380:	5188           	subql #8,%a0                                      	<== NOT EXECUTED
   55382:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   55384:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   55386:	65e4           	bcss 5536c <_Heap_Size_of_user_area+0x20>         	<== NOT EXECUTED
   55388:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   5538a:	62e0           	bhis 5536c <_Heap_Size_of_user_area+0x20>         	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   5538c:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   5538e:	c0a8 0004      	andl %a0@(4),%d0                                  	<== NOT EXECUTED
   55392:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
   55394:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   55396:	65d4           	bcss 5536c <_Heap_Size_of_user_area+0x20>         	<== NOT EXECUTED
   55398:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   5539a:	62d0           	bhis 5536c <_Heap_Size_of_user_area+0x20>         	<== 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 (
   5539c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   5539e:	c0a8 0004      	andl %a0@(4),%d0                                  	<== NOT EXECUTED
   553a2:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   553a4:	67c6           	beqs 5536c <_Heap_Size_of_user_area+0x20>         	<== 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 )
   553a6:	91c2           	subal %d2,%a0                                     	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
}
   553a8:	241f           	movel %sp@+,%d2                                   	<== 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 )
   553aa:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
}
   553ae:	261f           	movel %sp@+,%d3                                   	<== 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 )
   553b0:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
}
   553b2:	4e5e           	unlk %fp                                          	<== 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 )
   553b4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   553b6:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
}
   553b8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004ec44 <_Heap_Walk>:
bool _Heap_Walk(
  Heap_Control  *the_heap,
  int            source,
  bool           do_dump
)
{
   4ec44:	4e56 ffd8      	linkw %fp,#-40                                    	<== NOT EXECUTED
   4ec48:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   4ec4c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4ec50:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
  Heap_Block *the_block = the_heap->start;
   4ec54:	286a 0020      	moveal %a2@(32),%a4                               	<== NOT EXECUTED
  Heap_Block *const end = the_heap->final;
   4ec58:	2c2a 0024      	movel %a2@(36),%d6                                	<== NOT EXECUTED
/*
  if ( !_System_state_Is_up( _System_state_Get() ) )
    return TRUE;
*/

  if (source < 0)
   4ec5c:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4ec5e:	6d00 016c      	bltw 4edcc <_Heap_Walk+0x188>                     	<== NOT EXECUTED

  /*
   * Handle the 1st block
   */

  if (!_Heap_Is_prev_used(the_block)) {
   4ec62:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ec64:	c0ac 0004      	andl %a4@(4),%d0                                  	<== NOT EXECUTED
   4ec68:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4ec6a:	6700 0170      	beqw 4eddc <_Heap_Walk+0x198>                     	<== NOT EXECUTED
   4ec6e:	4284           	clrl %d4                                          	<== NOT EXECUTED
    printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
    error = 1;
  }

  if (the_block->prev_size != the_heap->page_size) {
   4ec70:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4ec74:	b094           	cmpl %a4@,%d0                                     	<== NOT EXECUTED
   4ec76:	6712           	beqs 4ec8a <_Heap_Walk+0x46>                      	<== NOT EXECUTED
    printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
   4ec78:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ec7a:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ec7c:	4879 0005 99a6 	pea 599a6 <status_flags_assoc+0x66>               	<== NOT EXECUTED
   4ec82:	4eb9 0004 5e9e 	jsr 45e9e <printk>                                	<== NOT EXECUTED
   4ec88:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    error = 1;
  }

  while ( the_block != end ) {
   4ec8a:	bc8c           	cmpl %a4,%d6                                      	<== NOT EXECUTED
   4ec8c:	6700 020e      	beqw 4ee9c <_Heap_Walk+0x258>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4ec90:	222c 0004      	movel %a4@(4),%d1                                 	<== NOT EXECUTED
   4ec94:	74fe           	moveq #-2,%d2                                     	<== NOT EXECUTED
   4ec96:	c481           	andl %d1,%d2                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4ec98:	47f4 2800      	lea %a4@(00000000,%d2:l),%a3                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in (
  Heap_Control *the_heap,
  Heap_Block   *the_block
)
{
  return _Addresses_Is_in_range( the_block, the_heap->start, the_heap->final );
   4ec9c:	202a 0024      	movel %a2@(36),%d0                                	<== NOT EXECUTED
   4eca0:	b7ea 0020      	cmpal %a2@(32),%a3                                	<== NOT EXECUTED
   4eca4:	6500 00a6      	bcsw 4ed4c <_Heap_Walk+0x108>                     	<== NOT EXECUTED
   4eca8:	b08b           	cmpl %a3,%d0                                      	<== NOT EXECUTED
   4ecaa:	6500 00a0      	bcsw 4ed4c <_Heap_Walk+0x108>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   4ecae:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   4ecb0:	c681           	andl %d1,%d3                                      	<== NOT EXECUTED
   4ecb2:	2e3c 0004 5e9e 	movel #286366,%d7                                 	<== NOT EXECUTED
      printk("PASS: %d !block %p is out of heap\n", source, next_block);
      error = 1;
      break;
    }

    if (!_Heap_Is_prev_used(next_block)) {
   4ecb8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ecba:	c0ab 0004      	andl %a3@(4),%d0                                  	<== NOT EXECUTED
   4ecbe:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4ecc0:	6648           	bnes 4ed0a <_Heap_Walk+0xc6>                      	<== 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) {
   4ecc2:	b493           	cmpl %a3@,%d2                                     	<== NOT EXECUTED
   4ecc4:	6710           	beqs 4ecd6 <_Heap_Walk+0x92>                      	<== NOT EXECUTED
        if (do_dump) printk("\n");
        printk("PASS: %d !front and back sizes don't match", source);
   4ecc6:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ecc8:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   4ecca:	4879 0005 99fb 	pea 599fb <status_flags_assoc+0xbb>               	<== NOT EXECUTED
   4ecd0:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4ecd2:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ecd4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
        error = 1;
      }
      if (!prev_used) {
   4ecd6:	4a03           	tstb %d3                                          	<== NOT EXECUTED
   4ecd8:	661a           	bnes 4ecf4 <_Heap_Walk+0xb0>                      	<== NOT EXECUTED
   4ecda:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED
        if (do_dump || error) printk("\n");
   4ece0:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4ece2:	6600 00ca      	bnew 4edae <_Heap_Walk+0x16a>                     	<== NOT EXECUTED
        printk("PASS: %d !two consecutive blocks are free", source);
   4ece6:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ece8:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ecea:	4879 0005 9a26 	pea 59a26 <status_flags_assoc+0xe6>               	<== NOT EXECUTED
   4ecf0:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ecf2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   4ecf4:	206a 0008      	moveal %a2@(8),%a0                                	<== 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)
   4ecf8:	b1cc           	cmpal %a4,%a0                                     	<== NOT EXECUTED
   4ecfa:	670e           	beqs 4ed0a <_Heap_Walk+0xc6>                      	<== NOT EXECUTED
   4ecfc:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   4ecfe:	6700 0130      	beqw 4ee30 <_Heap_Walk+0x1ec>                     	<== NOT EXECUTED
          block = block->next;
   4ed02:	2068 0008      	moveal %a0@(8),%a0                                	<== 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)
   4ed06:	b9c8           	cmpal %a0,%a4                                     	<== NOT EXECUTED
   4ed08:	66f2           	bnes 4ecfc <_Heap_Walk+0xb8>                      	<== NOT EXECUTED
          error = 1;
        }
      }

    }
    if (do_dump || error) printk("\n");
   4ed0a:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4ed0c:	6600 0194      	bnew 4eea2 <_Heap_Walk+0x25e>                     	<== NOT EXECUTED

    if (the_size < the_heap->min_block_size) {
   4ed10:	b4aa 0014      	cmpl %a2@(20),%d2                                 	<== NOT EXECUTED
   4ed14:	6500 0144      	bcsw 4ee5a <_Heap_Walk+0x216>                     	<== NOT EXECUTED
      printk("PASS: %d !block size is too small\n", source);
      error = 1;
      break;
    }
    if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
   4ed18:	4c6a 2000 0010 	remul %a2@(16),%d0,%d2                            	<== NOT EXECUTED
   4ed1e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4ed20:	6600 00e2      	bnew 4ee04 <_Heap_Walk+0x1c0>                     	<== NOT EXECUTED
      printk("PASS: %d !block size is misaligned\n", source);
      error = 1;
    }

    if (++passes > (do_dump ? 10 : 0) && error)
   4ed24:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4ed26:	6600 018c      	bnew 4eeb4 <_Heap_Walk+0x270>                     	<== 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 ) {
   4ed2a:	b7c6           	cmpal %d6,%a3                                     	<== NOT EXECUTED
   4ed2c:	6700 016e      	beqw 4ee9c <_Heap_Walk+0x258>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4ed30:	262b 0004      	movel %a3@(4),%d3                                 	<== NOT EXECUTED
   4ed34:	74fe           	moveq #-2,%d2                                     	<== NOT EXECUTED
   4ed36:	c483           	andl %d3,%d2                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
  void       *base,
  uint32_t    offset
)
{
  return (void *)((char *)base + offset);
   4ed38:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in (
  Heap_Control *the_heap,
  Heap_Block   *the_block
)
{
  return _Addresses_Is_in_range( the_block, the_heap->start, the_heap->final );
   4ed3a:	222a 0024      	movel %a2@(36),%d1                                	<== NOT EXECUTED
   4ed3e:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
  void *address,
  void *base,
  void *limit
)
{
  return (address >= base && address <= limit);
   4ed40:	b0aa 0020      	cmpl %a2@(32),%d0                                 	<== NOT EXECUTED
   4ed44:	6400 00ac      	bccw 4edf2 <_Heap_Walk+0x1ae>                     	<== NOT EXECUTED
      printk("PASS: %d !block %p is out of heap\n", source, next_block);
      error = 1;
      break;
    }

    if (!_Heap_Is_prev_used(next_block)) {
   4ed48:	284b           	moveal %a3,%a4                                    	<== NOT EXECUTED
   4ed4a:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
        printk(" (prev_size) %d", the_block->prev_size);
    }

    if (!_Heap_Is_block_in(the_heap, next_block)) {
      if (do_dump) printk("\n");
      printk("PASS: %d !block %p is out of heap\n", source, next_block);
   4ed4c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4ed4e:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED
   4ed54:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ed56:	4879 0005 99d8 	pea 599d8 <status_flags_assoc+0x98>               	<== NOT EXECUTED
   4ed5c:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ed5e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

    the_block = next_block;
  }

  if (the_block != end) {
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
   4ed64:	2f06           	movel %d6,%sp@-                                   	<== NOT EXECUTED
   4ed66:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ed68:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   4ed6a:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ed6c:	4879 0005 9ac0 	pea 59ac0 <status_flags_assoc+0x180>              	<== NOT EXECUTED
   4ed72:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ed74:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
   4ed7a:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4ed7e:	72fe           	moveq #-2,%d1                                     	<== NOT EXECUTED
   4ed80:	c2ac 0004      	andl %a4@(4),%d1                                  	<== NOT EXECUTED
   4ed84:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ed86:	6700 0104      	beqw 4ee8c <_Heap_Walk+0x248>                     	<== NOT EXECUTED
    printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
   4ed8a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4ed8c:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   4ed8e:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ed90:	4879 0005 9afb 	pea 59afb <status_flags_assoc+0x1bb>              	<== NOT EXECUTED
   4ed96:	4eb9 0004 5e9e 	jsr 45e9e <printk>                                	<== NOT EXECUTED
   4ed9c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  if(do_dump && error)
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );

  return error;

}
   4eda2:	4cee 3cfc ffd8 	moveml %fp@(-40),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   4eda8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
    printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
   4edaa:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  if(do_dump && error)
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );

  return error;

}
   4edac:	4e75           	rts                                               	<== NOT EXECUTED
        if (do_dump) printk("\n");
        printk("PASS: %d !front and back sizes don't match", source);
        error = 1;
      }
      if (!prev_used) {
        if (do_dump || error) printk("\n");
   4edae:	4879 0005 947d 	pea 5947d <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4edb4:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   4edb6:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4edb8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        printk("PASS: %d !two consecutive blocks are free", source);
   4edba:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4edbc:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4edbe:	4879 0005 9a26 	pea 59a26 <status_flags_assoc+0xe6>               	<== NOT EXECUTED
   4edc4:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4edc6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4edc8:	6000 ff2a      	braw 4ecf4 <_Heap_Walk+0xb0>                      	<== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) )
    return TRUE;
*/

  if (source < 0)
    source = the_heap->stats.instance;
   4edcc:	2a2a 0028      	movel %a2@(40),%d5                                	<== NOT EXECUTED

  /*
   * Handle the 1st block
   */

  if (!_Heap_Is_prev_used(the_block)) {
   4edd0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4edd2:	c0ac 0004      	andl %a4@(4),%d0                                  	<== NOT EXECUTED
   4edd6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4edd8:	6600 fe94      	bnew 4ec6e <_Heap_Walk+0x2a>                      	<== NOT EXECUTED
    printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
   4eddc:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4edde:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ede0:	4879 0005 9970 	pea 59970 <status_flags_assoc+0x30>               	<== NOT EXECUTED
   4ede6:	4eb9 0004 5e9e 	jsr 45e9e <printk>                                	<== NOT EXECUTED
   4edec:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4edee:	6000 fe80      	braw 4ec70 <_Heap_Walk+0x2c>                      	<== NOT EXECUTED
   4edf2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4edf4:	6500 ff52      	bcsw 4ed48 <_Heap_Walk+0x104>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   4edf8:	284b           	moveal %a3,%a4                                    	<== NOT EXECUTED
   4edfa:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4edfc:	c681           	andl %d1,%d3                                      	<== NOT EXECUTED
   4edfe:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
   4ee00:	6000 feb6      	braw 4ecb8 <_Heap_Walk+0x74>                      	<== NOT EXECUTED
      printk("PASS: %d !block size is too small\n", source);
      error = 1;
      break;
    }
    if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
      printk("PASS: %d !block size is misaligned\n", source);
   4ee04:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ee06:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED

    the_block = next_block;
  }

  if (the_block != end) {
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
   4ee0c:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
      printk("PASS: %d !block size is too small\n", source);
      error = 1;
      break;
    }
    if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
      printk("PASS: %d !block size is misaligned\n", source);
   4ee0e:	4879 0005 9a9c 	pea 59a9c <status_flags_assoc+0x15c>              	<== NOT EXECUTED
   4ee14:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee16:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

    the_block = next_block;
  }

  if (the_block != end) {
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
   4ee18:	2f06           	movel %d6,%sp@-                                   	<== NOT EXECUTED
   4ee1a:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   4ee1c:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ee1e:	4879 0005 9ac0 	pea 59ac0 <status_flags_assoc+0x180>              	<== NOT EXECUTED
   4ee24:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee26:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4ee2c:	6000 ff4c      	braw 4ed7a <_Heap_Walk+0x136>                     	<== NOT EXECUTED
   4ee30:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== 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;
        if(block != the_block) {
          if (do_dump || error) printk("\n");
   4ee36:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4ee38:	6636           	bnes 4ee70 <_Heap_Walk+0x22c>                     	<== NOT EXECUTED
          printk("PASS: %d !the_block not in the free list", source);
   4ee3a:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ee3c:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ee3e:	4879 0005 9a50 	pea 59a50 <status_flags_assoc+0x110>              	<== NOT EXECUTED
   4ee44:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee46:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
          error = 1;
        }
      }

    }
    if (do_dump || error) printk("\n");
   4ee48:	4879 0005 947d 	pea 5947d <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4ee4e:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee50:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    if (the_size < the_heap->min_block_size) {
   4ee52:	b4aa 0014      	cmpl %a2@(20),%d2                                 	<== NOT EXECUTED
   4ee56:	6400 fec0      	bccw 4ed18 <_Heap_Walk+0xd4>                      	<== NOT EXECUTED
      printk("PASS: %d !block size is too small\n", source);
   4ee5a:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ee5c:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED
   4ee62:	4879 0005 9a79 	pea 59a79 <status_flags_assoc+0x139>              	<== NOT EXECUTED
   4ee68:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee6a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ee6c:	6000 fef6      	braw 4ed64 <_Heap_Walk+0x120>                     	<== 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;
        if(block != the_block) {
          if (do_dump || error) printk("\n");
   4ee70:	4879 0005 947d 	pea 5947d <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4ee76:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   4ee78:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4ee7a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
          printk("PASS: %d !the_block not in the free list", source);
   4ee7c:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4ee7e:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4ee80:	4879 0005 9a50 	pea 59a50 <status_flags_assoc+0x110>              	<== NOT EXECUTED
   4ee86:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ee88:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ee8a:	60bc           	bras 4ee48 <_Heap_Walk+0x204>                     	<== NOT EXECUTED
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
   4ee8c:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4ee8e:	56c0           	sne %d0                                           	<== NOT EXECUTED
  if(do_dump && error)
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );

  return error;

}
   4ee90:	4cee 3cfc ffd8 	moveml %fp@(-40),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   4ee96:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
   4ee98:	4480           	negl %d0                                          	<== NOT EXECUTED
  if(do_dump && error)
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );

  return error;

}
   4ee9a:	4e75           	rts                                               	<== NOT EXECUTED
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
    printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
   4ee9c:	2846           	moveal %d6,%a4                                    	<== NOT EXECUTED
   4ee9e:	6000 feda      	braw 4ed7a <_Heap_Walk+0x136>                     	<== NOT EXECUTED
          error = 1;
        }
      }

    }
    if (do_dump || error) printk("\n");
   4eea2:	4879 0005 947d 	pea 5947d <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4eea8:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED
   4eeae:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4eeb0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4eeb2:	609e           	bras 4ee52 <_Heap_Walk+0x20e>                     	<== NOT EXECUTED
   4eeb4:	4bf9 0004 5e9e 	lea 45e9e <printk>,%a5                            	<== NOT EXECUTED
   4eeba:	6000 fea8      	braw 4ed64 <_Heap_Walk+0x120>                     	<== NOT EXECUTED
	...

0004639c <_IO_Initialize_all_drivers>:
 *
 *  Output Parameters: NONE
 */

void _IO_Initialize_all_drivers( void )
{
   4639c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   463a0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   463a2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   rtems_device_major_number major;

   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
   463a4:	4ab9 0005 89ce 	tstl 589ce <_IO_Number_of_drivers>                	<== NOT EXECUTED
   463aa:	6720           	beqs 463cc <_IO_Initialize_all_drivers+0x30>      	<== NOT EXECUTED
   463ac:	4282           	clrl %d2                                          	<== NOT EXECUTED
   463ae:	45f9 0004 b178 	lea 4b178 <rtems_io_initialize>,%a2               	<== NOT EXECUTED
     (void) rtems_io_initialize( major, 0, NULL );
   463b4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   463b6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   463b8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   463ba:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

void _IO_Initialize_all_drivers( void )
{
   rtems_device_major_number major;

   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
   463bc:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   463be:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   463c4:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   463ca:	65e8           	bcss 463b4 <_IO_Initialize_all_drivers+0x18>      	<== NOT EXECUTED
     (void) rtems_io_initialize( major, 0, NULL );
}
   463cc:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   463d0:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   463d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   463d6:	4e75           	rts

000463d8 <_IO_Manager_initialization>:
void _IO_Manager_initialization(
  rtems_driver_address_table *driver_table,
  uint32_t                    drivers_in_table,
  uint32_t                    number_of_drivers
)
{
   463d8:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   463dc:	48d7 003c      	moveml %d2-%d5,%sp@                               	<== NOT EXECUTED
   463e0:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   463e4:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   463e8:	262e 0010      	movel %fp@(16),%d3                                	<== 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 )
   463ec:	b883           	cmpl %d3,%d4                                      	<== NOT EXECUTED
   463ee:	6468           	bccs 46458 <_IO_Manager_initialization+0x80>      	<== 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 *)
   463f0:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   463f2:	2403           	movel %d3,%d2                                     	<== NOT EXECUTED
   463f4:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   463f6:	eb8a           	lsll #5,%d2                                       	<== NOT EXECUTED
   463f8:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   463fa:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   463fc:	4eb9 0004 9170 	jsr 49170 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )
      );
  _IO_Number_of_drivers = number_of_drivers;

  memset(
   46402:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46404:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED

  _IO_Driver_address_table = (rtems_driver_address_table *)
      _Workspace_Allocate_or_fatal_error(
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )
      );
  _IO_Number_of_drivers = number_of_drivers;
   46406:	23c3 0005 89ce 	movel %d3,589ce <_IO_Number_of_drivers>           	<== NOT EXECUTED

  memset(
   4640c:	2f00           	movel %d0,%sp@-                                   	<== 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 *)
   4640e:	23c0 0005 89d2 	movel %d0,589d2 <_IO_Driver_address_table>        	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )
      );
  _IO_Number_of_drivers = number_of_drivers;

  memset(
   46414:	4eb9 0004 ce28 	jsr 4ce28 <memset>                                	<== NOT EXECUTED
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   4641a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   46420:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   46422:	672a           	beqs 4644e <_IO_Manager_initialization+0x76>      	<== NOT EXECUTED
    _IO_Driver_address_table[index] = driver_table[index];
   46424:	2439 0005 89d2 	movel 589d2 <_IO_Driver_address_table>,%d2        	<== NOT EXECUTED
   4642a:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4642c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4642e:	2245           	moveal %d5,%a1                                    	<== NOT EXECUTED
   46430:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   46432:	d3c0           	addal %d0,%a1                                     	<== NOT EXECUTED
   46434:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
   46436:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
  memset(
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   46438:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
    _IO_Driver_address_table[index] = driver_table[index];
   4643a:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
  memset(
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   4643c:	0680 0000 0018 	addil #24,%d0                                     	<== NOT EXECUTED
    _IO_Driver_address_table[index] = driver_table[index];
   46442:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   46444:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   46446:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   46448:	2091           	movel %a1@,%a0@                                   	<== NOT EXECUTED
  memset(
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   4644a:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   4644c:	65e0           	bcss 4642e <_IO_Manager_initialization+0x56>      	<== NOT EXECUTED
    _IO_Driver_address_table[index] = driver_table[index];
  number_of_drivers = drivers_in_table;
}
   4644e:	4cee 003c fff0 	moveml %fp@(-16),%d2-%d5                          	<== NOT EXECUTED
   46454:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46456:	4e75           	rts                                               	<== 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;
   46458:	23c5 0005 89d2 	movel %d5,589d2 <_IO_Driver_address_table>        	<== NOT EXECUTED
    _IO_Number_of_drivers = number_of_drivers;
   4645e:	23c4 0005 89ce 	movel %d4,589ce <_IO_Number_of_drivers>           	<== NOT EXECUTED
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
    _IO_Driver_address_table[index] = driver_table[index];
  number_of_drivers = drivers_in_table;
}
   46464:	4cee 003c fff0 	moveml %fp@(-16),%d2-%d5                          	<== NOT EXECUTED
   4646a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4646c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046e9c <_ISR_Handler_initialization>:
 *
 *  Output parameters: NONE
 */

void _ISR_Handler_initialization( void )
{
   46e9c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46ea0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  _ISR_Signals_to_thread_executing = FALSE;
   46ea2:	4200           	clrb %d0                                          	<== NOT EXECUTED

  _ISR_Nest_level = 0;
   46ea4:	42b9 0005 87f2 	clrl 587f2 <_ISR_Nest_level>                      	<== NOT EXECUTED

#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
  _ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
   46eaa:	45f9 0004 9170 	lea 49170 <_Workspace_Allocate_or_fatal_error>,%a2	<== NOT EXECUTED
 *  Output parameters: NONE
 */

void _ISR_Handler_initialization( void )
{
  _ISR_Signals_to_thread_executing = FALSE;
   46eb0:	13c0 0005 88a0 	moveb %d0,588a0 <_ISR_Signals_to_thread_executing>	<== NOT EXECUTED

  _ISR_Nest_level = 0;

#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
  _ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
   46eb6:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   46eba:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

  _CPU_Initialize_vectors();

#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )

  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
   46ebc:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46ec2:	2228 001c      	movel %a0@(28),%d1                                	<== NOT EXECUTED
  _ISR_Signals_to_thread_executing = FALSE;

  _ISR_Nest_level = 0;

#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
  _ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
   46ec6:	23c0 0005 87ce 	movel %d0,587ce <_ISR_Vector_table>               	<== NOT EXECUTED

  _CPU_Initialize_vectors();

#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )

  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
   46ecc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46ece:	b2b9 0005 6c3e 	cmpl 56c3e <rtems_minimum_stack_size>,%d1         	<== NOT EXECUTED
   46ed4:	6526           	bcss 46efc <_ISR_Handler_initialization+0x60>     	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
    );

  _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error(
   46ed6:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   46ed8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
    _Configuration_Table->interrupt_stack_size
  );

  _CPU_Interrupt_stack_high = _Addresses_Add_offset(
   46eda:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46ee0:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   46ee2:	d2a8 001c      	addl %a0@(28),%d1                                 	<== NOT EXECUTED

#if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE )
  _CPU_Install_interrupt_stack();
#endif

}
   46ee6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED

  _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error(
    _Configuration_Table->interrupt_stack_size
  );

  _CPU_Interrupt_stack_high = _Addresses_Add_offset(
   46eea:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

#if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE )
  _CPU_Install_interrupt_stack();
#endif

}
   46eec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error(
    _Configuration_Table->interrupt_stack_size
  );

  _CPU_Interrupt_stack_high = _Addresses_Add_offset(
   46eee:	23c1 0005 8708 	movel %d1,58708 <_CPU_Interrupt_stack_high>       	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
    );

  _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error(
   46ef4:	23c0 0005 8764 	movel %d0,58764 <_CPU_Interrupt_stack_low>        	<== NOT EXECUTED

#if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE )
  _CPU_Install_interrupt_stack();
#endif

}
   46efa:	4e75           	rts                                               	<== NOT EXECUTED
  _CPU_Initialize_vectors();

#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )

  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
    _Internal_error_Occurred(
   46efc:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   46f00:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46f04:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46f06:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED

00046e40 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   46e40:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46e44:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46e46:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   46e4a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46e4c:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED

  _Internal_errors_What_happened.the_source  = the_source;
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;

  _User_extensions_Fatal( the_source, is_internal, the_error );
   46e50:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46e52:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46e54:	1001           	moveb %d1,%d0                                     	<== NOT EXECUTED
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   46e56:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

  _Internal_errors_What_happened.the_source  = the_source;
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;

  _User_extensions_Fatal( the_source, is_internal, the_error );
   46e5a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
  uint32_t                the_error
)
{

  _Internal_errors_What_happened.the_source  = the_source;
  _Internal_errors_What_happened.is_internal = is_internal;
   46e5c:	13c1 0005 8802 	moveb %d1,58802 <_Internal_errors_What_happened+0x4>	<== NOT EXECUTED

  _User_extensions_Fatal( the_source, is_internal, the_error );

  _System_state_Set( SYSTEM_STATE_FAILED );

  _CPU_Fatal_halt( the_error );
   46e62:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED

  _Internal_errors_What_happened.the_source  = the_source;
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;

  _User_extensions_Fatal( the_source, is_internal, the_error );
   46e68:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
  bool                    is_internal,
  uint32_t                the_error
)
{

  _Internal_errors_What_happened.the_source  = the_source;
   46e6a:	23c8 0005 87fe 	movel %a0,587fe <_Internal_errors_What_happened>  	<== NOT EXECUTED
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;
   46e70:	23c3 0005 8804 	movel %d3,58804 <_Internal_errors_What_happened+0x6>	<== NOT EXECUTED

  _User_extensions_Fatal( the_source, is_internal, the_error );
   46e76:	4eb9 0004 8d6a 	jsr 48d6a <_User_extensions_Fatal>                	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   46e7c:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   46e7e:	23c0 0005 88e6 	movel %d0,588e6 <_System_state_Current>           	<== NOT EXECUTED

  _System_state_Set( SYSTEM_STATE_FAILED );

  _CPU_Fatal_halt( the_error );
   46e84:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   46e86:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46e88:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   46e8a:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   46e8c:	223c dead beef 	movel #-559038737,%d1                             	<== NOT EXECUTED
   46e92:	4ac8           	halt                                              	<== NOT EXECUTED
   46e94:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46e9a:	60fe           	bras 46e9a <_Internal_error_Occurred+0x5a>        	<== NOT EXECUTED

0004ad8c <_Interrupt_Manager_initialization>:
 *
 *  Output parameters: NONE
 */

void _Interrupt_Manager_initialization( void )
{
   4ad8c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
}
   4ad90:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ad92:	4e75           	rts

00059700 <_Message_queue_Allocate>:
 *  Output parameters:
 *    the_message_queue - set if successful, NULL otherwise
 */

Message_queue_Control *_Message_queue_Allocate(void)
{
   59700:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return (Message_queue_Control *)
   59704:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   5970a:	4eb9 0005 54b4 	jsr 554b4 <_Objects_Allocate>                     	<== NOT EXECUTED
    _Objects_Allocate(&_Message_queue_Information);
}
   59710:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   59712:	4e75           	rts

0004ad94 <_Message_queue_Manager_initialization>:
 */

void _Message_queue_Manager_initialization(
  uint32_t   maximum_message_queues
)
{
   4ad94:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ad98:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ad9c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ad9e:	4878 0088      	pea 88 <FP_REGS_SAVED+0x48>                       	<== NOT EXECUTED
   4ada2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ada6:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4adaa:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4adae:	4879 0005 8a4e 	pea 58a4e <_Message_queue_Information>            	<== NOT EXECUTED
   4adb4:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4adba:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_MESSAGE_QUEUE,
    _Message_queue_MP_Process_packet
  );
#endif

}
   4adc0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4adc2:	4e75           	rts

00052898 <_Message_queue_Translate_core_message_queue_return_code>:
};

rtems_status_code _Message_queue_Translate_core_message_queue_return_code (
  uint32_t   status
)
{
   52898:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
    if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT )
      return RTEMS_INTERNAL_ERROR;
  #endif

  return _Message_queue_Translate_core_return_code_[status];
}
   5289c:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
};

rtems_status_code _Message_queue_Translate_core_message_queue_return_code (
  uint32_t   status
)
{
   528a0:	41f9 0006 4cac 	lea 64cac <_Message_queue_Translate_core_return_code_>,%a0	<== NOT EXECUTED
    if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT )
      return RTEMS_INTERNAL_ERROR;
  #endif

  return _Message_queue_Translate_core_return_code_[status];
}
   528a6:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   528aa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   528ac:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b64c <_Objects_API_maximum_class>:
#include <rtems/score/object.h>

int _Objects_API_maximum_class(
  uint32_t api
)
{
   4b64c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b650:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  switch (api) {
   4b654:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   4b656:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b658:	672a           	beqs 4b684 <_Objects_API_maximum_class+0x38>      	<== NOT EXECUTED
   4b65a:	6414           	bccs 4b670 <_Objects_API_maximum_class+0x24>      	<== NOT EXECUTED
   4b65c:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4b65e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b660:	6728           	beqs 4b68a <_Objects_API_maximum_class+0x3e>      	<== NOT EXECUTED
   4b662:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   4b666:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b668:	6714           	beqs 4b67e <_Objects_API_maximum_class+0x32>      	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b66a:	4e5e           	unlk %fp                                          	<== 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;
   4b66c:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b66e:	4e75           	rts                                               	<== NOT EXECUTED

int _Objects_API_maximum_class(
  uint32_t api
)
{
  switch (api) {
   4b670:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   4b674:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b676:	66f2           	bnes 4b66a <_Objects_API_maximum_class+0x1e>      	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b678:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

int _Objects_API_maximum_class(
  uint32_t api
)
{
  switch (api) {
   4b67a:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b67c:	4e75           	rts                                               	<== NOT EXECUTED
   4b67e:	4e5e           	unlk %fp                                          	<== 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;
   4b680:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b682:	4e75           	rts                                               	<== NOT EXECUTED
   4b684:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

int _Objects_API_maximum_class(
  uint32_t api
)
{
  switch (api) {
   4b686:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b688:	4e75           	rts                                               	<== NOT EXECUTED
   4b68a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

int _Objects_API_maximum_class(
  uint32_t api
)
{
  switch (api) {
   4b68c:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   4b68e:	4e75           	rts

00046f0c <_Objects_Allocate>:
 */

Objects_Control *_Objects_Allocate(
  Objects_Information *information
)
{
   46f0c:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   46f10:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   46f14:	246e 0008      	moveal %fp@(8),%a2                                	<== 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 )
   46f18:	4aaa 0016      	tstl %a2@(22)                                     	<== NOT EXECUTED
   46f1c:	660e           	bnes 46f2c <_Objects_Allocate+0x20>               	<== NOT EXECUTED
   46f1e:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
      information->inactive--;
    }
  }

  return the_object;
}
   46f20:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   46f26:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46f28:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   46f2a:	4e75           	rts                                               	<== 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 );
   46f2c:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   46f2e:	0682 0000 001e 	addil #30,%d2                                     	<== NOT EXECUTED
   46f34:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46f36:	47f9 0004 b1f8 	lea 4b1f8 <_Chain_Get>,%a3                        	<== NOT EXECUTED
   46f3c:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

  if ( information->auto_extend ) {
   46f3e:	588f           	addql #4,%sp                                      	<== 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 );
   46f40:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED

  if ( information->auto_extend ) {
   46f42:	4a2a 0010      	tstb %a2@(16)                                     	<== NOT EXECUTED
   46f46:	67d8           	beqs 46f20 <_Objects_Allocate+0x14>               	<== NOT EXECUTED
    /*
     *  If the list is empty then we are out of objects and need to
     *  extend information base.
     */

    if ( !the_object ) {
   46f48:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46f4a:	673c           	beqs 46f88 <_Objects_Allocate+0x7c>               	<== NOT EXECUTED
    }

    if ( the_object ) {
      uint32_t   block;

      block = _Objects_Get_index( the_object->id ) -
   46f4c:	222a 0006      	movel %a2@(6),%d1                                 	<== NOT EXECUTED
   46f50:	2029 0008      	movel %a1@(8),%d0                                 	<== NOT EXECUTED
   46f54:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   46f5a:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   46f60:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   46f62:	4c6a 0000 0012 	remul %a2@(18),%d0,%d0                            	<== NOT EXECUTED
   46f68:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
      information->inactive--;
   46f6c:	322a 002a      	movew %a2@(42),%d1                                	<== NOT EXECUTED

      block = _Objects_Get_index( the_object->id ) -
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   46f70:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
      information->inactive--;
   46f72:	5381           	subql #1,%d1                                      	<== NOT EXECUTED

      block = _Objects_Get_index( the_object->id ) -
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   46f74:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
      information->inactive--;
   46f76:	3541 002a      	movew %d1,%a2@(42)                                	<== NOT EXECUTED
    }
  }

  return the_object;
}
   46f7a:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED

      block = _Objects_Get_index( the_object->id ) -
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   46f80:	5390           	subql #1,%a0@                                     	<== NOT EXECUTED
      information->inactive--;
    }
  }

  return the_object;
}
   46f82:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46f84:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   46f86:	4e75           	rts                                               	<== NOT EXECUTED
     *  If the list is empty then we are out of objects and need to
     *  extend information base.
     */

    if ( !the_object ) {
      _Objects_Extend_information( information );
   46f88:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46f8a:	4eb9 0004 6fd4 	jsr 46fd4 <_Objects_Extend_information>           	<== NOT EXECUTED
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
   46f90:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46f92:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
    }

    if ( the_object ) {
   46f94:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
     *  extend information base.
     */

    if ( !the_object ) {
      _Objects_Extend_information( information );
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
   46f96:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
    }

    if ( the_object ) {
   46f98:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46f9a:	66b0           	bnes 46f4c <_Objects_Allocate+0x40>               	<== NOT EXECUTED
      information->inactive--;
    }
  }

  return the_object;
}
   46f9c:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   46fa2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46fa4:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   46fa6:	4e75           	rts

00046fa8 <_Objects_Close>:

void _Objects_Close(
  Objects_Information  *information,
  Objects_Control      *the_object
)
{
   46fa8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46fac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46fae:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   46fb2:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   46fb6:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   46fba:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46fbc:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
   46fc0:	42b0 0c00      	clrl %a0@(00000000,%d0:l:4)                       	<== NOT EXECUTED
  _Objects_Invalidate_Id( information, the_object );

  _Objects_Namespace_remove( information, the_object );
   46fc4:	2d49 000c      	movel %a1,%fp@(12)                                	<== NOT EXECUTED
}
   46fc8:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   46fca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Control      *the_object
)
{
  _Objects_Invalidate_Id( information, the_object );

  _Objects_Namespace_remove( information, the_object );
   46fcc:	4ef9 0004 75a0 	jmp 475a0 <_Objects_Namespace_remove>             	<== NOT EXECUTED
	...

00046fd4 <_Objects_Extend_information>:
 */

void _Objects_Extend_information(
  Objects_Information *information
)
{
   46fd4:	4e56 ffc8      	linkw %fp,#-56                                    	<== NOT EXECUTED
   46fd8:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   46fdc:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index(
  Objects_Id id
)
{
  return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS;
   46fe0:	262b 0006      	movel %a3@(6),%d3                                 	<== NOT EXECUTED

  minimum_index = _Objects_Get_index( information->minimum_id );
  index_base    = minimum_index;
  block         = 0;

  if ( information->maximum < minimum_index )
   46fe4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46fe6:	0283 0000 ffff 	andil #65535,%d3                                  	<== NOT EXECUTED
   46fec:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   46ff0:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   46ff2:	6300 01a4      	blsw 47198 <_Objects_Extend_information+0x1c4>    	<== NOT EXECUTED
   46ff6:	242b 0012      	movel %a3@(18),%d2                                	<== NOT EXECUTED
     *  Up the block count and maximum
     */

    block_count++;

    maximum = information->maximum + information->allocation_size;
   46ffa:	2e02           	movel %d2,%d7                                     	<== NOT EXECUTED

  minimum_index = _Objects_Get_index( information->minimum_id );
  index_base    = minimum_index;
  block         = 0;

  if ( information->maximum < minimum_index )
   46ffc:	2a03           	movel %d3,%d5                                     	<== NOT EXECUTED
   46ffe:	95ca           	subal %a2,%a2                                     	<== NOT EXECUTED
   47000:	4284           	clrl %d4                                          	<== NOT EXECUTED
   47002:	7c01           	moveq #1,%d6                                      	<== NOT EXECUTED
   47004:	307c 0003      	moveaw #3,%a0                                     	<== NOT EXECUTED
     *  Up the block count and maximum
     */

    block_count++;

    maximum = information->maximum + information->allocation_size;
   47008:	de80           	addl %d0,%d7                                      	<== NOT EXECUTED

    /*
     *  Allocate the tables and break it up.
     */

    if ( information->auto_extend ) {
   4700a:	4a2b 0010      	tstb %a3@(16)                                     	<== NOT EXECUTED
   4700e:	6700 01d0      	beqw 471e0 <_Objects_Extend_information+0x20c>    	<== NOT EXECUTED
      object_blocks = (void**)
   47012:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   47014:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED
   47016:	d087           	addl %d7,%d0                                      	<== NOT EXECUTED
   47018:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4701a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4701c:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED
          block_count *
             (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *))
          );

      if ( !object_blocks )
   47022:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    /*
     *  Allocate the tables and break it up.
     */

    if ( information->auto_extend ) {
      object_blocks = (void**)
   47024:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED
          block_count *
             (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *))
          );

      if ( !object_blocks )
   47026:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47028:	6700 0164      	beqw 4718e <_Objects_Extend_information+0x1ba>    	<== NOT EXECUTED
    /*
     *  Break the block into the various sections.
     *
     */

    inactive_per_block = (uint32_t *) _Addresses_Add_offset(
   4702c:	2206           	movel %d6,%d1                                     	<== NOT EXECUTED
   4702e:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   47030:	4bf4 1800      	lea %a4@(00000000,%d1:l),%a5                      	<== NOT EXECUTED
     *  in the copies.
     */

    block_count--;

    if ( information->maximum > minimum_index ) {
   47034:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47036:	43f5 1800      	lea %a5@(00000000,%d1:l),%a1                      	<== NOT EXECUTED
   4703a:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   4703e:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47040:	6500 01ca      	bcsw 4720c <_Objects_Extend_information+0x238>    	<== NOT EXECUTED
    else {

      /*
       *  Deal with the special case of the 0 to minimum_index
       */
      for ( index = 0; index < minimum_index; index++ ) {
   47044:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   47046:	670c           	beqs 47054 <_Objects_Extend_information+0x80>     	<== NOT EXECUTED
              information->object_blocks,
              block_count * sizeof(void*) );
      memcpy( inactive_per_block,
              information->inactive_per_block,
              block_count * sizeof(uint32_t) );
      memcpy( local_table,
   47048:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   4704a:	4280           	clrl %d0                                          	<== NOT EXECUTED

      /*
       *  Deal with the special case of the 0 to minimum_index
       */
      for ( index = 0; index < minimum_index; index++ ) {
        local_table[ index ] = NULL;
   4704c:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
    else {

      /*
       *  Deal with the special case of the 0 to minimum_index
       */
      for ( index = 0; index < minimum_index; index++ ) {
   4704e:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47050:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47052:	62f8           	bhis 4704c <_Objects_Extend_information+0x78>     	<== NOT EXECUTED
   47054:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   47056:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
    /*
     *  Initialise the new entries in the table.
     */

    object_blocks[block_count] = NULL;
    inactive_per_block[block_count] = 0;
   47058:	42b5 2800      	clrl %a5@(00000000,%d2:l)                         	<== NOT EXECUTED

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
   4705c:	2205           	movel %d5,%d1                                     	<== NOT EXECUTED
   4705e:	d2ab 0012      	addl %a3@(18),%d1                                 	<== NOT EXECUTED

    /*
     *  Initialise the new entries in the table.
     */

    object_blocks[block_count] = NULL;
   47062:	42b4 2800      	clrl %a4@(00000000,%d2:l)                         	<== NOT EXECUTED
    inactive_per_block[block_count] = 0;

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
   47066:	b285           	cmpl %d5,%d1                                      	<== NOT EXECUTED
   47068:	630e           	blss 47078 <_Objects_Extend_information+0xa4>     	<== NOT EXECUTED
   4706a:	41f1 5c00      	lea %a1@(00000000,%d5:l:4),%a0                    	<== NOT EXECUTED
   4706e:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
          index++ ) {
      local_table[ index ] = NULL;
   47070:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
    object_blocks[block_count] = NULL;
    inactive_per_block[block_count] = 0;

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
          index++ ) {
   47072:	5280           	addql #1,%d0                                      	<== NOT EXECUTED

    object_blocks[block_count] = NULL;
    inactive_per_block[block_count] = 0;

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
   47074:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47076:	62f8           	bhis 47070 <_Objects_Extend_information+0x9c>     	<== NOT EXECUTED
          index++ ) {
      local_table[ index ] = NULL;
    }

    _ISR_Disable( level );
   47078:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4707e:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   47080:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   47082:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    information->object_blocks = object_blocks;
    information->inactive_per_block = inactive_per_block;
    information->local_table = local_table;
    information->maximum = maximum;
    information->maximum_id = _Objects_Build_id(
   47084:	2013           	movel %a3@,%d0                                    	<== NOT EXECUTED
   47086:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   47088:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   4708a:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4708c:	322b 0004      	movew %a3@(4),%d1                                 	<== NOT EXECUTED
   47090:	741b           	moveq #27,%d2                                     	<== NOT EXECUTED
   47092:	e5a9           	lsll %d2,%d1                                      	<== NOT EXECUTED
      local_table[ index ] = NULL;
    }

    _ISR_Disable( level );

    old_tables = information->object_blocks;
   47094:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED

    information->object_blocks = object_blocks;
    information->inactive_per_block = inactive_per_block;
    information->local_table = local_table;
    information->maximum = maximum;
    information->maximum_id = _Objects_Build_id(
   47098:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   4709c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4709e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   470a0:	3407           	movew %d7,%d2                                     	<== NOT EXECUTED
   470a2:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   470a4:	2740 000a      	movel %d0,%a3@(10)                                	<== NOT EXECUTED
    old_tables = information->object_blocks;

    information->object_blocks = object_blocks;
    information->inactive_per_block = inactive_per_block;
    information->local_table = local_table;
    information->maximum = maximum;
   470a8:	3747 000e      	movew %d7,%a3@(14)                                	<== NOT EXECUTED

    _ISR_Disable( level );

    old_tables = information->object_blocks;

    information->object_blocks = object_blocks;
   470ac:	274c 0030      	movel %a4,%a3@(48)                                	<== NOT EXECUTED
    information->inactive_per_block = inactive_per_block;
   470b0:	274d 002c      	movel %a5,%a3@(44)                                	<== NOT EXECUTED
    information->local_table = local_table;
   470b4:	2749 001a      	movel %a1,%a3@(26)                                	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        information->maximum
      );

    _ISR_Enable( level );
   470b8:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED

    if ( old_tables )
   470ba:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   470bc:	6700 01f6      	beqw 472b4 <_Objects_Extend_information+0x2e0>    	<== NOT EXECUTED
      _Workspace_Free( old_tables );
   470c0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   470c2:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   470c8:	242b 0012      	movel %a3@(18),%d2                                	<== NOT EXECUTED
   470cc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  /*
   *  Allocate the name table, and the objects
   */

  if ( information->auto_extend ) {
   470ce:	4a2b 0010      	tstb %a3@(16)                                     	<== NOT EXECUTED
   470d2:	6700 0180      	beqw 47254 <_Objects_Extend_information+0x280>    	<== NOT EXECUTED
    information->object_blocks[ block ] =
   470d6:	202b 0016      	movel %a3@(22),%d0                                	<== NOT EXECUTED
   470da:	4c02 0800      	mulsl %d2,%d0                                     	<== NOT EXECUTED
   470de:	2c04           	movel %d4,%d6                                     	<== NOT EXECUTED
   470e0:	e58e           	lsll #2,%d6                                       	<== NOT EXECUTED
   470e2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   470e4:	246b 0030      	moveal %a3@(48),%a2                               	<== NOT EXECUTED
   470e8:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED
      _Workspace_Allocate(
        (information->allocation_size * information->size)
      );

    if ( !information->object_blocks[ block ] )
   470ee:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
  /*
   *  Allocate the name table, and the objects
   */

  if ( information->auto_extend ) {
    information->object_blocks[ block ] =
   470f2:	d5c6           	addal %d6,%a2                                     	<== NOT EXECUTED
   470f4:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Workspace_Allocate(
        (information->allocation_size * information->size)
      );

    if ( !information->object_blocks[ block ] )
   470f6:	2030 6800      	movel %a0@(00000000,%d6:l),%d0                    	<== NOT EXECUTED
   470fa:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   470fc:	6700 0090      	beqw 4718e <_Objects_Extend_information+0x1ba>    	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   47100:	2f2b 0016      	movel %a3@(22),%sp@-                              	<== NOT EXECUTED
   47104:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   47106:	260b           	movel %a3,%d3                                     	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   47108:	2f2b 0012      	movel %a3@(18),%sp@-                              	<== NOT EXECUTED
   4710c:	0684 ffff fff4 	addil #-12,%d4                                    	<== NOT EXECUTED
   47112:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   47114:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   47116:	0683 0000 001e 	addil #30,%d3                                     	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   4711c:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4711e:	4eb9 0004 b234 	jsr 4b234 <_Chain_Initialize>                     	<== NOT EXECUTED
   47124:	49f9 0004 b1f8 	lea 4b1f8 <_Chain_Get>,%a4                        	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   4712a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   47130:	45f9 0004 66d8 	lea 466d8 <_Chain_Append>,%a2                     	<== 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 ) {
   47136:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   47138:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   4713a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4713c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4713e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47140:	6734           	beqs 47176 <_Objects_Extend_information+0x1a2>    	<== NOT EXECUTED

    the_object->id = _Objects_Build_id(
   47142:	2013           	movel %a3@,%d0                                    	<== NOT EXECUTED
   47144:	7a18           	moveq #24,%d5                                     	<== NOT EXECUTED
   47146:	eba8           	lsll %d5,%d0                                      	<== NOT EXECUTED
   47148:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4714a:	322b 0004      	movew %a3@(4),%d1                                 	<== NOT EXECUTED
   4714e:	1a3c 001b      	moveb #27,%d5                                     	<== NOT EXECUTED
   47152:	eba9           	lsll %d5,%d1                                      	<== NOT EXECUTED
   47154:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   47158:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4715a:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4715c:	2140 0008      	movel %d0,%a0@(8)                                 	<== NOT EXECUTED
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );

    index++;
   47160:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   47162:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   47164:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47166:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

    index++;
   47168:	508f           	addql #8,%sp                                      	<== 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 ) {
   4716a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4716c:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   4716e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47170:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   47172:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47174:	66cc           	bnes 47142 <_Objects_Extend_information+0x16e>    	<== NOT EXECUTED
    _Chain_Append( &information->Inactive, &the_object->Node );

    index++;
  }

  information->inactive_per_block[ block ] = information->allocation_size;
   47176:	206b 002c      	moveal %a3@(44),%a0                               	<== NOT EXECUTED
   4717a:	43eb 0012      	lea %a3@(18),%a1                                  	<== NOT EXECUTED
   4717e:	2191 6800      	movel %a1@,%a0@(00000000,%d6:l)                   	<== NOT EXECUTED
  information->inactive += information->allocation_size;
   47182:	302b 002a      	movew %a3@(42),%d0                                	<== NOT EXECUTED
   47186:	d0ab 0012      	addl %a3@(18),%d0                                 	<== NOT EXECUTED
   4718a:	3740 002a      	movew %d0,%a3@(42)                                	<== NOT EXECUTED
}
   4718e:	4cee 3cfc ffc8 	moveml %fp@(-56),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   47194:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47196:	4e75           	rts                                               	<== NOT EXECUTED
  block         = 0;

  if ( information->maximum < minimum_index )
    block_count = 0;
  else {
    block_count = information->maximum / information->allocation_size;
   47198:	242b 0012      	movel %a3@(18),%d2                                	<== NOT EXECUTED
   4719c:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4719e:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED
   471a2:	2441           	moveal %d1,%a2                                    	<== NOT EXECUTED

    for ( ; block < block_count; block++ ) {
   471a4:	6700 0116      	beqw 472bc <_Objects_Extend_information+0x2e8>    	<== NOT EXECUTED
      if ( information->object_blocks[ block ] == NULL )
   471a8:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
   471ac:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   471ae:	6700 010c      	beqw 472bc <_Objects_Extend_information+0x2e8>    	<== NOT EXECUTED
   471b2:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   471b4:	2a03           	movel %d3,%d5                                     	<== NOT EXECUTED
   471b6:	4284           	clrl %d4                                          	<== NOT EXECUTED
        break;
      else
        index_base += information->allocation_size;
   471b8:	da82           	addl %d2,%d5                                      	<== NOT EXECUTED
  if ( information->maximum < minimum_index )
    block_count = 0;
  else {
    block_count = information->maximum / information->allocation_size;

    for ( ; block < block_count; block++ ) {
   471ba:	5284           	addql #1,%d4                                      	<== NOT EXECUTED
   471bc:	b881           	cmpl %d1,%d4                                      	<== NOT EXECUTED
   471be:	6404           	bccs 471c4 <_Objects_Extend_information+0x1f0>    	<== NOT EXECUTED
      if ( information->object_blocks[ block ] == NULL )
   471c0:	4a98           	tstl %a0@+                                        	<== NOT EXECUTED
   471c2:	66f4           	bnes 471b8 <_Objects_Extend_information+0x1e4>    	<== NOT EXECUTED

  /*
   *  If the index_base is the maximum we need to grow the tables.
   */

  if (index_base >= information->maximum ) {
   471c4:	b085           	cmpl %d5,%d0                                      	<== NOT EXECUTED
   471c6:	6200 ff06      	bhiw 470ce <_Objects_Extend_information+0xfa>     	<== NOT EXECUTED
   471ca:	2c01           	movel %d1,%d6                                     	<== NOT EXECUTED
   471cc:	5286           	addql #1,%d6                                      	<== NOT EXECUTED
   471ce:	2246           	moveal %d6,%a1                                    	<== NOT EXECUTED
     *  Up the block count and maximum
     */

    block_count++;

    maximum = information->maximum + information->allocation_size;
   471d0:	2e02           	movel %d2,%d7                                     	<== NOT EXECUTED

  /*
   *  If the index_base is the maximum we need to grow the tables.
   */

  if (index_base >= information->maximum ) {
   471d2:	41f1 6a00      	lea %a1@(00000000,%d6:l:2),%a0                    	<== NOT EXECUTED
     *  Up the block count and maximum
     */

    block_count++;

    maximum = information->maximum + information->allocation_size;
   471d6:	de80           	addl %d0,%d7                                      	<== NOT EXECUTED

    /*
     *  Allocate the tables and break it up.
     */

    if ( information->auto_extend ) {
   471d8:	4a2b 0010      	tstb %a3@(16)                                     	<== NOT EXECUTED
   471dc:	6600 fe34      	bnew 47012 <_Objects_Extend_information+0x3e>     	<== NOT EXECUTED

      if ( !object_blocks )
        return;
    }
    else {
      object_blocks = (void**)
   471e0:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   471e2:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED
   471e4:	d087           	addl %d7,%d0                                      	<== NOT EXECUTED
   471e6:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   471e8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   471ea:	4eb9 0004 9170 	jsr 49170 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
    /*
     *  Break the block into the various sections.
     *
     */

    inactive_per_block = (uint32_t *) _Addresses_Add_offset(
   471f0:	2206           	movel %d6,%d1                                     	<== NOT EXECUTED

      if ( !object_blocks )
        return;
    }
    else {
      object_blocks = (void**)
   471f2:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED
    /*
     *  Break the block into the various sections.
     *
     */

    inactive_per_block = (uint32_t *) _Addresses_Add_offset(
   471f4:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   471f6:	4bf4 1800      	lea %a4@(00000000,%d1:l),%a5                      	<== NOT EXECUTED
     *  in the copies.
     */

    block_count--;

    if ( information->maximum > minimum_index ) {
   471fa:	4280           	clrl %d0                                          	<== NOT EXECUTED

      if ( !object_blocks )
        return;
    }
    else {
      object_blocks = (void**)
   471fc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   471fe:	43f5 1800      	lea %a5@(00000000,%d1:l),%a1                      	<== NOT EXECUTED
     *  in the copies.
     */

    block_count--;

    if ( information->maximum > minimum_index ) {
   47202:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   47206:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47208:	6400 fe3a      	bccw 47044 <_Objects_Extend_information+0x70>     	<== 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,
   4720c:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   4720e:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   47210:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47212:	45f9 0004 cdb8 	lea 4cdb8 <memcpy>,%a2                            	<== NOT EXECUTED
   47218:	2f2b 0030      	movel %a3@(48),%sp@-                              	<== NOT EXECUTED
   4721c:	2d49 fff0      	movel %a1,%fp@(-16)                               	<== NOT EXECUTED
   47220:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   47222:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
              information->object_blocks,
              block_count * sizeof(void*) );
      memcpy( inactive_per_block,
   47224:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47226:	2f2b 002c      	movel %a3@(44),%sp@-                              	<== NOT EXECUTED
   4722a:	2f0d           	movel %a5,%sp@-                                   	<== NOT EXECUTED
   4722c:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
              information->inactive_per_block,
              block_count * sizeof(uint32_t) );
      memcpy( local_table,
   4722e:	4281           	clrl %d1                                          	<== NOT EXECUTED
   47230:	322b 000e      	movew %a3@(14),%d1                                	<== NOT EXECUTED
   47234:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   47236:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   47238:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   4723a:	226e fff0      	moveal %fp@(-16),%a1                              	<== NOT EXECUTED
   4723e:	2f2b 001a      	movel %a3@(26),%sp@-                              	<== NOT EXECUTED
   47242:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   47244:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   47246:	226e fff0      	moveal %fp@(-16),%a1                              	<== NOT EXECUTED
   4724a:	dffc 0000 0024 	addal #36,%sp                                     	<== NOT EXECUTED
   47250:	6000 fe06      	braw 47058 <_Objects_Extend_information+0x84>     	<== NOT EXECUTED

    if ( !information->object_blocks[ block ] )
      return;
  }
  else {
    information->object_blocks[ block ] =
   47254:	222b 0016      	movel %a3@(22),%d1                                	<== NOT EXECUTED
   47258:	4c02 1800      	mulsl %d2,%d1                                     	<== NOT EXECUTED
   4725c:	2c04           	movel %d4,%d6                                     	<== NOT EXECUTED
   4725e:	e58e           	lsll #2,%d6                                       	<== NOT EXECUTED
   47260:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   47262:	246b 0030      	moveal %a3@(48),%a2                               	<== NOT EXECUTED
   47266:	4eb9 0004 9170 	jsr 49170 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
   4726c:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
   47270:	d5c6           	addal %d6,%a2                                     	<== NOT EXECUTED
   47272:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   47274:	2030 6800      	movel %a0@(00000000,%d6:l),%d0                    	<== NOT EXECUTED
   47278:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   4727a:	2f2b 0016      	movel %a3@(22),%sp@-                              	<== NOT EXECUTED
   4727e:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   47280:	2f2b 0012      	movel %a3@(18),%sp@-                              	<== NOT EXECUTED
   47284:	0684 ffff fff4 	addil #-12,%d4                                    	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   4728a:	260b           	movel %a3,%d3                                     	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   4728c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   4728e:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   47290:	0683 0000 001e 	addil #30,%d3                                     	<== NOT EXECUTED

  /*
   *  Initialize objects .. add to a local chain first.
   */

  _Chain_Initialize(
   47296:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   47298:	4eb9 0004 b234 	jsr 4b234 <_Chain_Initialize>                     	<== NOT EXECUTED
   4729e:	49f9 0004 b1f8 	lea 4b1f8 <_Chain_Get>,%a4                        	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   472a4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   472aa:	45f9 0004 66d8 	lea 466d8 <_Chain_Append>,%a2                     	<== NOT EXECUTED
   472b0:	6000 fe84      	braw 47136 <_Objects_Extend_information+0x162>    	<== NOT EXECUTED
        information->maximum
      );

    _ISR_Enable( level );

    if ( old_tables )
   472b4:	242b 0012      	movel %a3@(18),%d2                                	<== NOT EXECUTED
   472b8:	6000 fe14      	braw 470ce <_Objects_Extend_information+0xfa>     	<== NOT EXECUTED
  if ( information->maximum < minimum_index )
    block_count = 0;
  else {
    block_count = information->maximum / information->allocation_size;

    for ( ; block < block_count; block++ ) {
   472bc:	2a03           	movel %d3,%d5                                     	<== NOT EXECUTED
   472be:	4284           	clrl %d4                                          	<== NOT EXECUTED

  /*
   *  If the index_base is the maximum we need to grow the tables.
   */

  if (index_base >= information->maximum ) {
   472c0:	b085           	cmpl %d5,%d0                                      	<== NOT EXECUTED
   472c2:	6200 fe0a      	bhiw 470ce <_Objects_Extend_information+0xfa>     	<== NOT EXECUTED
   472c6:	6000 ff02      	braw 471ca <_Objects_Extend_information+0x1f6>    	<== NOT EXECUTED
	...

000472cc <_Objects_Free>:

void _Objects_Free(
  Objects_Information *information,
  Objects_Control     *the_object
)
{
   472cc:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   472d0:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   472d4:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   472d8:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  uint32_t    allocation_size = information->allocation_size;

  _Chain_Append( &information->Inactive, &the_object->Node );
   472dc:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
void _Objects_Free(
  Objects_Information *information,
  Objects_Control     *the_object
)
{
  uint32_t    allocation_size = information->allocation_size;
   472de:	242a 0012      	movel %a2@(18),%d2                                	<== NOT EXECUTED

  _Chain_Append( &information->Inactive, &the_object->Node );
   472e2:	486a 001e      	pea %a2@(30)                                      	<== NOT EXECUTED
   472e6:	4eb9 0004 66d8 	jsr 466d8 <_Chain_Append>                         	<== NOT EXECUTED

  if ( information->auto_extend ) {
   472ec:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   472ee:	4a2a 0010      	tstb %a2@(16)                                     	<== NOT EXECUTED
   472f2:	6740           	beqs 47334 <_Objects_Free+0x68>                   	<== NOT EXECUTED
    uint32_t    block;

    block =
   472f4:	202b 0008      	movel %a3@(8),%d0                                 	<== NOT EXECUTED
   472f8:	222a 0006      	movel %a2@(6),%d1                                 	<== NOT EXECUTED
   472fc:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   47302:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   47308:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
      _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
    block /= information->allocation_size;

    information->inactive_per_block[ block ]++;
   4730a:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   4730e:	4c6a 0000 0012 	remul %a2@(18),%d0,%d0                            	<== NOT EXECUTED
   47314:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   47316:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
    information->inactive++;
   47318:	302a 002a      	movew %a2@(42),%d0                                	<== NOT EXECUTED
   4731c:	5280           	addql #1,%d0                                      	<== 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 ) ) ) {
   4731e:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED

    block =
      _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
    block /= information->allocation_size;

    information->inactive_per_block[ block ]++;
   47320:	5290           	addql #1,%a0@                                     	<== 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 ) ) ) {
   47322:	e289           	lsrl #1,%d1                                       	<== NOT EXECUTED
    block =
      _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
    block /= information->allocation_size;

    information->inactive_per_block[ block ]++;
    information->inactive++;
   47324:	3540 002a      	movew %d0,%a2@(42)                                	<== 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 ) ) ) {
   47328:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   4732a:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   47330:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47332:	650a           	bcss 4733e <_Objects_Free+0x72>                   	<== NOT EXECUTED
      _Objects_Shrink_information( information );
    }
  }
}
   47334:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4733a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4733c:	4e75           	rts                                               	<== 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 );
   4733e:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
    }
  }
}
   47342:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   47348:	4e5e           	unlk %fp                                          	<== 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 );
   4734a:	4ef9 0004 765c 	jmp 4765c <_Objects_Shrink_information>           	<== NOT EXECUTED

00047438 <_Objects_Get>:
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   47438:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4743c:	206e 0008      	moveal %fp@(8),%a0                                	<== 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;
   47440:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   47442:	92a8 0006      	subl %a0@(6),%d1                                  	<== NOT EXECUTED
   47446:	d2ae 000c      	addl %fp@(12),%d1                                 	<== 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 ) {
   4744a:	4280           	clrl %d0                                          	<== NOT EXECUTED
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   4744c:	2f02           	movel %d2,%sp@-                                   	<== 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 ) {
   4744e:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   47452:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47454:	6528           	bcss 4747e <_Objects_Get+0x46>                    	<== NOT EXECUTED
   47456:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4745c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4745e:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    _Thread_Disable_dispatch();
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   47464:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   47468:	2430 1c00      	movel %a0@(00000000,%d1:l:4),%d2                  	<== NOT EXECUTED
   4746c:	6724           	beqs 47492 <_Objects_Get+0x5a>                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   4746e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   *  index into the local_table array.
   */
  if ( index <= information->maximum ) {
    _Thread_Disable_dispatch();
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
   47470:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47474:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   47478:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *  index into the local_table array.
   */
  if ( index <= information->maximum ) {
    _Thread_Disable_dispatch();
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
   4747a:	4290           	clrl %a0@                                         	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   4747c:	4e75           	rts                                               	<== 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;
   4747e:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   47482:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47484:	4282           	clrl %d2                                          	<== NOT EXECUTED
   47486:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47488:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4748a:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4748e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47490:	4e75           	rts                                               	<== NOT EXECUTED

    /*
     *  Valid Id for this API, Class and Node but the object has not
     *  been allocated yet.
     */
    _Thread_Enable_dispatch();
   47492:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47498:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
    /*
     *  Valid Id for this API, Class and Node but the object has not
     *  been allocated yet.
     */
    _Thread_Enable_dispatch();
    *location = OBJECTS_ERROR;
   4749a:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   4749e:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
    /*
     *  Valid Id for this API, Class and Node but the object has not
     *  been allocated yet.
     */
    _Thread_Enable_dispatch();
    *location = OBJECTS_ERROR;
   474a2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   474a4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    /*
     *  Valid Id for this API, Class and Node but the object has not
     *  been allocated yet.
     */
    _Thread_Enable_dispatch();
    *location = OBJECTS_ERROR;
   474a6:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   474a8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004737c <_Objects_Get_information>:

Objects_Information *_Objects_Get_information(
  Objects_APIs   the_api,
  uint32_t       the_class
)
{
   4737c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   47380:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   47384:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   47386:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47388:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4738a:	6506           	bcss 47392 <_Objects_Get_information+0x16>        	<== NOT EXECUTED
  int the_class_api_maximum;

  if ( !_Objects_Is_api_valid( the_api ) )
    return NULL;

  if ( !the_class )
   4738c:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   47390:	6608           	bnes 4739a <_Objects_Get_information+0x1e>        	<== 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 )
   47392:	91c8           	subal %a0,%a0                                     	<== NOT EXECUTED
      return NULL;
  #endif

  return info;
}
   47394:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47396:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   47398:	4e75           	rts                                               	<== NOT EXECUTED
    return NULL;

  if ( !the_class )
    return NULL;

  the_class_api_maximum = _Objects_API_maximum_class( the_api );
   4739a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4739e:	4eb9 0004 b64c 	jsr 4b64c <_Objects_API_maximum_class>            	<== NOT EXECUTED
  if ( the_class_api_maximum < 0 ||
   473a4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   473a6:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   473a8:	6de8           	blts 47392 <_Objects_Get_information+0x16>        	<== NOT EXECUTED
   473aa:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   473ae:	65e2           	bcss 47392 <_Objects_Get_information+0x16>        	<== NOT EXECUTED
       the_class > (uint32_t) the_class_api_maximum )
    return NULL;

  if ( !_Objects_Information_table[ the_api ] )
   473b0:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   473b4:	41f9 0005 870c 	lea 5870c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   473ba:	2070 0c00      	moveal %a0@(00000000,%d0:l:4),%a0                 	<== NOT EXECUTED
   473be:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   473c0:	67d0           	beqs 47392 <_Objects_Get_information+0x16>        	<== NOT EXECUTED
    return NULL;

  info = _Objects_Information_table[ the_api ][ the_class ];
   473c2:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   473c6:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
  if ( !info )
   473ca:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   473cc:	67c6           	beqs 47394 <_Objects_Get_information+0x18>        	<== 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 )
   473ce:	4a68 000e      	tstw %a0@(14)                                     	<== NOT EXECUTED
   473d2:	67be           	beqs 47392 <_Objects_Get_information+0x16>        	<== NOT EXECUTED
      return NULL;
  #endif

  return info;
}
   473d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   473d6:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   473d8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047350 <_Objects_Get_information_id>:
#include <rtems/score/thread.h>

Objects_Information *_Objects_Get_information_id(
  Objects_Id  id
)
{
   47350:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47354:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   47358:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  return _Objects_Get_information(
   4735a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4735c:	741b           	moveq #27,%d2                                     	<== NOT EXECUTED
   4735e:	e4a9           	lsrl %d2,%d1                                      	<== NOT EXECUTED
   47360:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   47362:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   47364:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   47366:	143c 0007      	moveb #7,%d2                                      	<== NOT EXECUTED
   4736a:	c480           	andl %d0,%d2                                      	<== NOT EXECUTED
   4736c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4736e:	4eb9 0004 737c 	jsr 4737c <_Objects_Get_information>              	<== NOT EXECUTED
    _Objects_Get_API( id ),
    _Objects_Get_class( id )
  );
}
   47374:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   47378:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4737a:	4e75           	rts

000473dc <_Objects_Get_isr_disable>:
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location,
  ISR_Level           *level_p
)
{
   473dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   473e0:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   473e4:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  index = id - information->minimum_id + 1;
#else
  /* index = _Objects_Get_index( id ); */
  index = id & 0x0000ffff;
   473e8:	4281           	clrl %d1                                          	<== NOT EXECUTED
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location,
  ISR_Level           *level_p
)
{
   473ea:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  index = id & 0x0000ffff;
  /* This should work but doesn't always :( */
  /* index = (uint16_t  ) id; */
#endif

  _ISR_Disable( level );
   473ec:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  index = id - information->minimum_id + 1;
#else
  /* index = _Objects_Get_index( id ); */
  index = id & 0x0000ffff;
   473f2:	322e 000e      	movew %fp@(14),%d1                                	<== NOT EXECUTED
  /* This should work but doesn't always :( */
  /* index = (uint16_t  ) id; */
#endif

  _ISR_Disable( level );
   473f6:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   473f8:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   473fa:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( information->maximum >= index ) {
   473fc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   473fe:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   47402:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47404:	6518           	bcss 4741e <_Objects_Get_isr_disable+0x42>        	<== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   47406:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   4740a:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   4740e:	671c           	beqs 4742c <_Objects_Get_isr_disable+0x50>        	<== NOT EXECUTED
      *location = OBJECTS_LOCAL;
      *level_p = level;
   47410:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   47414:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47416:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47418:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
#endif

  _ISR_Disable( level );
  if ( information->maximum >= index ) {
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
   4741a:	4291           	clrl %a1@                                         	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   4741c:	4e75           	rts                                               	<== NOT EXECUTED
    }
    _ISR_Enable( level );
    *location = OBJECTS_ERROR;
    return NULL;
  }
  _ISR_Enable( level );
   4741e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47420:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
    _ISR_Enable( level );
    *location = OBJECTS_ERROR;
    return NULL;
  }
  _ISR_Enable( level );
  *location = OBJECTS_ERROR;
   47422:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47424:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _ISR_Enable( level );
    *location = OBJECTS_ERROR;
    return NULL;
  }
  _ISR_Enable( level );
  *location = OBJECTS_ERROR;
   47426:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47428:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   4742a:	4e75           	rts                                               	<== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
      *level_p = level;
      return the_object;
    }
    _ISR_Enable( level );
   4742c:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
   4742e:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   47430:	2282           	movel %d2,%a1@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   47432:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47434:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47436:	4e75           	rts

00053488 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
  Objects_Id        id,
  size_t            length,
  char             *name
)
{
   53488:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   5348c:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   53490:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
  char                   lname[5];
  Objects_Control       *the_object;
  Objects_Locations      location;
  Objects_Id             tmpId;

  if ( length == 0 )
   53494:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   53498:	660e           	bnes 534a8 <_Objects_Get_name_as_string+0x20>     	<== NOT EXECUTED
        }
      }
      *d = '\0';

      _Thread_Enable_dispatch();
      return name;
   5349a:	4284           	clrl %d4                                          	<== NOT EXECUTED
  }
  return NULL;                  /* unreachable path */
}
   5349c:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   5349e:	4cee 0c1c ffe0 	moveml %fp@(-32),%d2-%d4/%a2-%a3                  	<== NOT EXECUTED
   534a4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   534a6:	4e75           	rts                                               	<== NOT EXECUTED
  Objects_Id             tmpId;

  if ( length == 0 )
    return NULL;

  if ( name == NULL )
   534a8:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   534aa:	67f0           	beqs 5349c <_Objects_Get_name_as_string+0x14>     	<== NOT EXECUTED
    return NULL;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   534ac:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   534b0:	6700 0098      	beqw 5354a <_Objects_Get_name_as_string+0xc2>     	<== NOT EXECUTED
   534b4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED

  information = _Objects_Get_information_id( tmpId );
   534b8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   534ba:	4eb9 0004 cbe0 	jsr 4cbe0 <_Objects_Get_information_id>           	<== NOT EXECUTED
  if ( !information )
   534c0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  if ( name == NULL )
    return NULL;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;

  information = _Objects_Get_information_id( tmpId );
   534c2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  if ( !information )
   534c4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   534c6:	67d2           	beqs 5349a <_Objects_Get_name_as_string+0x12>     	<== NOT EXECUTED
    return NULL;

  the_object = _Objects_Get( information, tmpId, &location );
   534c8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   534cc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   534ce:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   534d0:	4eb9 0004 ccc8 	jsr 4ccc8 <_Objects_Get>                          	<== NOT EXECUTED
  switch ( location ) {
   534d6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

  information = _Objects_Get_information_id( tmpId );
  if ( !information )
    return NULL;

  the_object = _Objects_Get( information, tmpId, &location );
   534dc:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   534de:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   534e2:	66b6           	bnes 5349a <_Objects_Get_name_as_string+0x12>     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      return NULL;

    case OBJECTS_LOCAL:

      if ( information->is_string ) {
   534e4:	4a2a 0034      	tstb %a2@(52)                                     	<== NOT EXECUTED
   534e8:	676e           	beqs 53558 <_Objects_Get_name_as_string+0xd0>     	<== NOT EXECUTED
        s = the_object->name.name_p;
   534ea:	2668 000c      	moveal %a0@(12),%a3                               	<== NOT EXECUTED
        lname[ 4 ] = '\0';
        s = lname;
      }

      d = name;
      if ( s ) {
   534ee:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   534f0:	674c           	beqs 5353e <_Objects_Get_name_as_string+0xb6>     	<== NOT EXECUTED
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   534f2:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   534f6:	5383           	subql #1,%d3                                      	<== NOT EXECUTED
   534f8:	6744           	beqs 5353e <_Objects_Get_name_as_string+0xb6>     	<== NOT EXECUTED
   534fa:	1413           	moveb %a3@,%d2                                    	<== NOT EXECUTED
   534fc:	6740           	beqs 5353e <_Objects_Get_name_as_string+0xb6>     	<== NOT EXECUTED
   534fe:	2444           	moveal %d4,%a2                                    	<== NOT EXECUTED
   53500:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
   53502:	2079 0006 4eac 	moveal 64eac <__ctype_ptr>,%a0                    	<== NOT EXECUTED
   53508:	1202           	moveb %d2,%d1                                     	<== NOT EXECUTED
   5350a:	49c1           	extbl %d1                                         	<== NOT EXECUTED
   5350c:	1030 1800      	moveb %a0@(00000000,%d1:l),%d0                    	<== NOT EXECUTED
   53510:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   53512:	0280 0000 0097 	andil #151,%d0                                    	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   53518:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
   5351a:	6602           	bnes 5351e <_Objects_Get_name_as_string+0x96>     	<== NOT EXECUTED
   5351c:	742a           	moveq #42,%d2                                     	<== NOT EXECUTED
   5351e:	14c2           	moveb %d2,%a2@+                                   	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   53520:	b689           	cmpl %a1,%d3                                      	<== NOT EXECUTED
   53522:	6306           	blss 5352a <_Objects_Get_name_as_string+0xa2>     	<== NOT EXECUTED
   53524:	1433 9800      	moveb %a3@(00000000,%a1:l),%d2                    	<== NOT EXECUTED
   53528:	66d8           	bnes 53502 <_Objects_Get_name_as_string+0x7a>     	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
        }
      }
      *d = '\0';
   5352a:	4212           	clrb %a2@                                         	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   5352c:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return name;
  }
  return NULL;                  /* unreachable path */
}
   53532:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   53534:	4cee 0c1c ffe0 	moveml %fp@(-32),%d2-%d4/%a2-%a3                  	<== NOT EXECUTED
   5353a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5353c:	4e75           	rts                                               	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   5353e:	2444           	moveal %d4,%a2                                    	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
        }
      }
      *d = '\0';
   53540:	4212           	clrb %a2@                                         	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   53542:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   53548:	60e8           	bras 53532 <_Objects_Get_name_as_string+0xaa>     	<== NOT EXECUTED
    return NULL;

  if ( name == NULL )
    return NULL;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   5354a:	2079 0006 6c9a 	moveal 66c9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   53550:	2428 0008      	movel %a0@(8),%d2                                 	<== NOT EXECUTED
   53554:	6000 ff62      	braw 534b8 <_Objects_Get_name_as_string+0x30>     	<== 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;
   53558:	2028 000c      	movel %a0@(12),%d0                                	<== NOT EXECUTED

        lname[ 0 ] = (u32_name >> 24) & 0xff;
   5355c:	7418           	moveq #24,%d2                                     	<== NOT EXECUTED
   5355e:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   53560:	e4a9           	lsrl %d2,%d1                                      	<== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;
   53562:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   53564:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
   53566:	1d40 fffa      	moveb %d0,%fp@(-6)                                	<== NOT EXECUTED
        s = the_object->name.name_p;
      } else {
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;

        lname[ 0 ] = (u32_name >> 24) & 0xff;
        lname[ 1 ] = (u32_name >> 16) & 0xff;
   5356a:	4242           	clrw %d2                                          	<== NOT EXECUTED
   5356c:	4842           	swap %d2                                          	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   5356e:	e08b           	lsrl #8,%d3                                       	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
        lname[ 4 ] = '\0';
   53570:	4200           	clrb %d0                                          	<== NOT EXECUTED
      if ( information->is_string ) {
        s = the_object->name.name_p;
      } else {
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;

        lname[ 0 ] = (u32_name >> 24) & 0xff;
   53572:	1d41 fff7      	moveb %d1,%fp@(-9)                                	<== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;
   53576:	1d42 fff8      	moveb %d2,%fp@(-8)                                	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   5357a:	1d43 fff9      	moveb %d3,%fp@(-7)                                	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
        lname[ 4 ] = '\0';
   5357e:	1d40 fffb      	moveb %d0,%fp@(-5)                                	<== NOT EXECUTED
   53582:	47ee fff7      	lea %fp@(-9),%a3                                  	<== NOT EXECUTED
   53586:	6000 ff6a      	braw 534f2 <_Objects_Get_name_as_string+0x6a>     	<== NOT EXECUTED
	...

00056170 <_Objects_Get_next>:
    Objects_Information *information,
    Objects_Id           id,
    Objects_Locations   *location_p,
    Objects_Id          *next_id_p
)
{
   56170:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   56174:	48d7 3c04      	moveml %d2/%a2-%a5,%sp@                           	<== NOT EXECUTED
   56178:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   5617c:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   56180:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   56184:	2a6e 0014      	moveal %fp@(20),%a5                               	<== NOT EXECUTED
    Objects_Control *object;
    Objects_Id       next_id;

    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
   56188:	4a40           	tstw %d0                                          	<== NOT EXECUTED
   5618a:	673a           	beqs 561c6 <_Objects_Get_next+0x56>               	<== NOT EXECUTED
   5618c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
            *location_p = OBJECTS_ERROR;
            goto final;
        }

        /* try to grab one */
        object = _Objects_Get(information, next_id, location_p);
   5618e:	49f9 0004 ccc8 	lea 4ccc8 <_Objects_Get>,%a4                      	<== NOT EXECUTED
    else
        next_id = id;

    do {
        /* walked off end of list? */
        if (_Objects_Get_index(next_id) > information->maximum)
   56194:	4281           	clrl %d1                                          	<== NOT EXECUTED
   56196:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   56198:	322b 000e      	movew %a3@(14),%d1                                	<== NOT EXECUTED
   5619c:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   561a2:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   561a4:	622c           	bhis 561d2 <_Objects_Get_next+0x62>               	<== NOT EXECUTED
            *location_p = OBJECTS_ERROR;
            goto final;
        }

        /* try to grab one */
        object = _Objects_Get(information, next_id, location_p);
   561a6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   561a8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

        next_id++;
   561aa:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
            *location_p = OBJECTS_ERROR;
            goto final;
        }

        /* try to grab one */
        object = _Objects_Get(information, next_id, location_p);
   561ac:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   561ae:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

        next_id++;

    } while (*location_p != OBJECTS_LOCAL);
   561b0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   561b6:	4a92           	tstl %a2@                                         	<== NOT EXECUTED
   561b8:	66da           	bnes 56194 <_Objects_Get_next+0x24>               	<== NOT EXECUTED

    *next_id_p = next_id;
   561ba:	2a82           	movel %d2,%a5@                                    	<== NOT EXECUTED
    return object;

final:
    *next_id_p = OBJECTS_ID_FINAL;
    return 0;
}
   561bc:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   561c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   561c4:	4e75           	rts                                               	<== NOT EXECUTED
{
    Objects_Control *object;
    Objects_Id       next_id;

    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
        next_id = information->minimum_id;
   561c6:	242b 0006      	movel %a3@(6),%d2                                 	<== NOT EXECUTED
            *location_p = OBJECTS_ERROR;
            goto final;
        }

        /* try to grab one */
        object = _Objects_Get(information, next_id, location_p);
   561ca:	49f9 0004 ccc8 	lea 4ccc8 <_Objects_Get>,%a4                      	<== NOT EXECUTED
   561d0:	60c2           	bras 56194 <_Objects_Get_next+0x24>               	<== NOT EXECUTED

    do {
        /* walked off end of list? */
        if (_Objects_Get_index(next_id) > information->maximum)
        {
            *location_p = OBJECTS_ERROR;
   561d2:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED

    *next_id_p = next_id;
    return object;

final:
    *next_id_p = OBJECTS_ID_FINAL;
   561d4:	72ff           	moveq #-1,%d1                                     	<== NOT EXECUTED

    do {
        /* walked off end of list? */
        if (_Objects_Get_index(next_id) > information->maximum)
        {
            *location_p = OBJECTS_ERROR;
   561d6:	2482           	movel %d2,%a2@                                    	<== NOT EXECUTED

    *next_id_p = next_id;
    return object;

final:
    *next_id_p = OBJECTS_ID_FINAL;
   561d8:	4280           	clrl %d0                                          	<== NOT EXECUTED
   561da:	2a81           	movel %d1,%a5@                                    	<== NOT EXECUTED
    return 0;
}
   561dc:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   561e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   561e4:	4e75           	rts                                               	<== NOT EXECUTED
	...

000559e0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   559e0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   559e4:	206e 0008      	moveal %fp@(8),%a0                                	<== 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;
   559e8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   559ea:	92a8 0006      	subl %a0@(6),%d1                                  	<== NOT EXECUTED
   559ee:	d2ae 000c      	addl %fp@(12),%d1                                 	<== NOT EXECUTED

  if ( information->maximum >= index ) {
   559f2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   559f4:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   559f8:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   559fa:	6514           	bcss 55a10 <_Objects_Get_no_protection+0x30>      	<== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   559fc:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   55a00:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   55a04:	670a           	beqs 55a10 <_Objects_Get_no_protection+0x30>      	<== NOT EXECUTED
      *location = OBJECTS_LOCAL;
   55a06:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   *  This isn't supported or required yet for Global objects so
   *  if it isn't local, we don't find it.
   */
  *location = OBJECTS_ERROR;
  return NULL;
}
   55a0a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */
  index = id - information->minimum_id + 1;

  if ( information->maximum >= index ) {
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
   55a0c:	4290           	clrl %a0@                                         	<== NOT EXECUTED
   *  This isn't supported or required yet for Global objects so
   *  if it isn't local, we don't find it.
   */
  *location = OBJECTS_ERROR;
  return NULL;
}
   55a0e:	4e75           	rts                                               	<== 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;
   55a10:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   55a14:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  return NULL;
}
   55a16:	4e5e           	unlk %fp                                          	<== 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;
   55a18:	4280           	clrl %d0                                          	<== NOT EXECUTED
   55a1a:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  return NULL;
}
   55a1c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047654 <_Objects_Handler_initialization>:
  uint32_t   maximum_nodes,
  uint32_t   maximum_global_objects )
#else
void _Objects_Handler_initialization(void)
#endif
{
   47654:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
    node,
    maximum_nodes,
    maximum_global_objects
  );
#endif
}
   47658:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4765a:	4e75           	rts

00048504 <_Objects_Id_to_name>:

Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
  Objects_Id      id,
  Objects_Name   *name
)
{
   48504:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   48508:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4850a:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4850e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Id           tmpId;
  Objects_Information *information;
  Objects_Control     *the_object = (Objects_Control *) 0;
  Objects_Locations    ignored_location;

  if ( !name )
   48510:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   48514:	6700 00a4      	beqw 485ba <_Objects_Id_to_name+0xb6>             	<== NOT EXECUTED
    return OBJECTS_INVALID_NAME;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   48518:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4851a:	6678           	bnes 48594 <_Objects_Id_to_name+0x90>             	<== NOT EXECUTED
   4851c:	2079 0005 ac9a 	moveal 5ac9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   48522:	2428 0008      	movel %a0@(8),%d2                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
  Objects_Id id
)
{
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
   48526:	7018           	moveq #24,%d0                                     	<== NOT EXECUTED
   48528:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4852a:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   4852c:	7607           	moveq #7,%d3                                      	<== NOT EXECUTED
   4852e:	c283           	andl %d3,%d1                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   48530:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   48532:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   48534:	163c 0003      	moveb #3,%d3                                      	<== NOT EXECUTED
   48538:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   4853a:	6570           	bcss 485ac <_Objects_Id_to_name+0xa8>             	<== 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 ] )
   4853c:	41f9 0005 ab94 	lea 5ab94 <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   48542:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
   48546:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48548:	6762           	beqs 485ac <_Objects_Id_to_name+0xa8>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  the_class = _Objects_Get_class( tmpId );

  information = _Objects_Information_table[ the_api ][ the_class ];
   4854a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4854c:	721b           	moveq #27,%d1                                     	<== NOT EXECUTED
   4854e:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   48550:	2070 0c00      	moveal %a0@(00000000,%d0:l:4),%a0                 	<== NOT EXECUTED
  if ( !information )
   48554:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48556:	6754           	beqs 485ac <_Objects_Id_to_name+0xa8>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  if ( information->is_string )
   48558:	4a28 0034      	tstb %a0@(52)                                     	<== NOT EXECUTED
   4855c:	664e           	bnes 485ac <_Objects_Id_to_name+0xa8>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  the_object = _Objects_Get( information, tmpId, &ignored_location );
   4855e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   48562:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48564:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   48566:	4eb9 0004 8490 	jsr 48490 <_Objects_Get>                          	<== NOT EXECUTED
  if ( !the_object )
   4856c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  if ( information->is_string )
    return OBJECTS_INVALID_ID;

  the_object = _Objects_Get( information, tmpId, &ignored_location );
   48572:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( !the_object )
   48574:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   48576:	6734           	beqs 485ac <_Objects_Id_to_name+0xa8>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  *name = the_object->name;
   48578:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   4857c:	22a8 000c      	movel %a0@(12),%a1@                               	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   48580:	4eb9 0004 8dd8 	jsr 48dd8 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   48586:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
   48588:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4858c:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   48590:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48592:	4e75           	rts                                               	<== NOT EXECUTED
  Objects_Locations    ignored_location;

  if ( !name )
    return OBJECTS_INVALID_NAME;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   48594:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
  Objects_Id id
)
{
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
   48596:	7018           	moveq #24,%d0                                     	<== NOT EXECUTED
   48598:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4859a:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   4859c:	7607           	moveq #7,%d3                                      	<== NOT EXECUTED
   4859e:	c283           	andl %d3,%d1                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   485a0:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   485a2:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   485a4:	163c 0003      	moveb #3,%d3                                      	<== NOT EXECUTED
   485a8:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   485aa:	6490           	bccs 4853c <_Objects_Id_to_name+0x38>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  *name = the_object->name;
  _Thread_Enable_dispatch();
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
   485ac:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   485b0:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   485b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  if ( !the_object )
    return OBJECTS_INVALID_ID;

  *name = the_object->name;
  _Thread_Enable_dispatch();
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
   485b6:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
}
   485b8:	4e75           	rts                                               	<== NOT EXECUTED
   485ba:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   485be:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   485c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id           tmpId;
  Objects_Information *information;
  Objects_Control     *the_object = (Objects_Control *) 0;
  Objects_Locations    ignored_location;

  if ( !name )
   485c4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  *name = the_object->name;
  _Thread_Enable_dispatch();
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
   485c6:	4e75           	rts

000474ac <_Objects_Initialize_information>:
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   474ac:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   474b0:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED

  /*
   *  Set the entry in the object information table.
   */

  _Objects_Information_table[ the_api ][ the_class ] = information;
   474b4:	41f9 0005 870c 	lea 5870c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   474ba:	2270 0c00      	moveal %a0@(00000000,%d0:l:4),%a1                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   474be:	48d7 007c      	moveml %d2-%d6,%sp@                               	<== NOT EXECUTED
   474c2:	282e 0014      	movel %fp@(20),%d4                                	<== NOT EXECUTED
   474c6:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   474ca:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   *  Are we operating in unlimited, or auto-extend mode
   */

  information->auto_extend =
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
  maximum                 &= ~OBJECTS_UNLIMITED_OBJECTS;
   474ce:	2c04           	movel %d4,%d6                                     	<== NOT EXECUTED
   474d0:	0886 001f      	bclr #31,%d6                                      	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   474d4:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
  uint32_t                name_length;
#if defined(RTEMS_MULTIPROCESSING)
  uint32_t                index;
#endif

  information->the_api            = the_api;
   474d6:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   474d8:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   474da:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   474dc:	56c3           	sne %d3                                           	<== NOT EXECUTED
   474de:	123c 001b      	moveb #27,%d1                                     	<== NOT EXECUTED

  /*
   *  Set the entry in the object information table.
   */

  _Objects_Information_table[ the_api ][ the_class ] = information;
   474e2:	2388 2c00      	movel %a0,%a1@(00000000,%d2:l:4)                  	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  uint32_t                index;
#endif

  information->the_api            = the_api;
  information->the_class          = the_class;
   474e6:	3142 0004      	movew %d2,%a0@(4)                                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   474ea:	2a2e 0020      	movel %fp@(32),%d5                                	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   474ee:	e3aa           	lsll %d1,%d2                                      	<== NOT EXECUTED
   474f0:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   474f4:	49c3           	extbl %d3                                         	<== NOT EXECUTED
   474f6:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   474f8:	4483           	negl %d3                                          	<== NOT EXECUTED
   474fa:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   474fc:	4281           	clrl %d1                                          	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   474fe:	2140 0006      	movel %d0,%a0@(6)                                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   47502:	322e 001a      	movew %fp@(26),%d1                                	<== NOT EXECUTED

  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;

  information->inactive           = 0;
   47506:	4240           	clrw %d0                                          	<== NOT EXECUTED

  /*
   *  Set the size of the object
   */

  information->size = size;
   47508:	2141 0016      	movel %d1,%a0@(22)                                	<== NOT EXECUTED

  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;

  information->inactive           = 0;
   4750c:	3140 002a      	movew %d0,%a0@(42)                                	<== NOT EXECUTED

  /*
   *  Are we operating in unlimited, or auto-extend mode
   */

  information->auto_extend =
   47510:	d884           	addl %d4,%d4                                      	<== NOT EXECUTED
   47512:	9984           	subxl %d4,%d4                                     	<== NOT EXECUTED
   47514:	4484           	negl %d4                                          	<== NOT EXECUTED
  uint32_t                index;
#endif

  information->the_api            = the_api;
  information->the_class          = the_class;
  information->is_string          = is_string;
   47516:	116e 001f 0034 	moveb %fp@(31),%a0@(52)                           	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   4751c:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED

  /*
   *  Provide a null local table entry for the case of any empty table.
   */

  information->local_table = &null_local_table;
   4751e:	223c 0005 7f04 	movel #360196,%d1                                 	<== NOT EXECUTED

  /*
   *  Are we operating in unlimited, or auto-extend mode
   */

  information->auto_extend =
   47524:	1144 0010      	moveb %d4,%a0@(16)                                	<== NOT EXECUTED
  information->the_api            = the_api;
  information->the_class          = the_class;
  information->is_string          = is_string;

  information->local_table        = 0;
  information->inactive_per_block = 0;
   47528:	42a8 002c      	clrl %a0@(44)                                     	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   4752c:	c085           	andl %d5,%d0                                      	<== NOT EXECUTED

  /*
   *  Provide a null local table entry for the case of any empty table.
   */

  information->local_table = &null_local_table;
   4752e:	2141 001a      	movel %d1,%a0@(26)                                	<== NOT EXECUTED
  information->the_class          = the_class;
  information->is_string          = is_string;

  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;
   47532:	42a8 0030      	clrl %a0@(48)                                     	<== NOT EXECUTED

  /*
   *  The allocation unit is the maximum value
   */

  information->allocation_size = maximum;
   47536:	2146 0012      	movel %d6,%a0@(18)                                	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   4753a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4753c:	6626           	bnes 47564 <_Objects_Initialize_information+0xb8> 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4753e:	43e8 0022      	lea %a0@(34),%a1                                  	<== NOT EXECUTED
   47542:	2149 001e      	movel %a1,%a0@(30)                                	<== NOT EXECUTED
   47546:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   47548:	43e8 001e      	lea %a0@(30),%a1                                  	<== NOT EXECUTED
    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
                  ~(OBJECTS_NAME_ALIGNMENT-1);

  information->name_length = name_length;
   4754c:	3140 0036      	movew %d0,%a0@(54)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   47550:	42a8 0022      	clrl %a0@(34)                                     	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   47554:	2149 0026      	movel %a1,%a0@(38)                                	<== NOT EXECUTED

  /*
   *  Initialize objects .. if there are any
   */

  if ( maximum ) {
   47558:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   4755a:	662c           	bnes 47588 <_Objects_Initialize_information+0xdc> 	<== NOT EXECUTED
      _Chain_Initialize_empty( &information->global_table[ index ] );
   }
   else
     information->global_table = NULL;
#endif
}
   4755c:	4cd7 007c      	moveml %sp@,%d2-%d6                               	<== NOT EXECUTED
   47560:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47562:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47564:	43e8 0022      	lea %a0@(34),%a1                                  	<== NOT EXECUTED
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
   47568:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4756a:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4756c:	72fc           	moveq #-4,%d1                                     	<== NOT EXECUTED
   4756e:	2149 001e      	movel %a1,%a0@(30)                                	<== NOT EXECUTED
   47572:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   47574:	43e8 001e      	lea %a0@(30),%a1                                  	<== NOT EXECUTED
                  ~(OBJECTS_NAME_ALIGNMENT-1);

  information->name_length = name_length;
   47578:	3140 0036      	movew %d0,%a0@(54)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   4757c:	42a8 0022      	clrl %a0@(34)                                     	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   47580:	2149 0026      	movel %a1,%a0@(38)                                	<== NOT EXECUTED

  /*
   *  Initialize objects .. if there are any
   */

  if ( maximum ) {
   47584:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   47586:	67d4           	beqs 4755c <_Objects_Initialize_information+0xb0> 	<== 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 );
   47588:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
      _Chain_Initialize_empty( &information->global_table[ index ] );
   }
   else
     information->global_table = NULL;
#endif
}
   4758c:	4cd7 007c      	moveml %sp@,%d2-%d6                               	<== NOT EXECUTED
   47590:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    /*
     *  Reset the maximum value. It will be updated when the information is
     *  extended.
     */

    information->maximum = 0;
   47592:	4240           	clrw %d0                                          	<== NOT EXECUTED
   47594:	3140 000e      	movew %d0,%a0@(14)                                	<== 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 );
   47598:	4ef9 0004 6fd4 	jmp 46fd4 <_Objects_Extend_information>           	<== NOT EXECUTED
	...

000475d0 <_Objects_Name_to_id_u32>:
  Objects_Information *information,
  uint32_t             name,
  uint32_t             node,
  Objects_Id          *id
)
{
   475d0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   475d4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   475d6:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Objects_Name               name_for_mp;
#endif

  /* ASSERT: information->is_string == FALSE */

  if ( !id )
   475da:	4aae 0014      	tstl %fp@(20)                                     	<== NOT EXECUTED
   475de:	676a           	beqs 4764a <_Objects_Name_to_id_u32+0x7a>         	<== NOT EXECUTED
    return OBJECTS_INVALID_ADDRESS;

  if ( name == 0 )
   475e0:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   475e2:	6738           	beqs 4761c <_Objects_Name_to_id_u32+0x4c>         	<== NOT EXECUTED
    return OBJECTS_INVALID_NAME;

  search_local_node = FALSE;

  if ( information->maximum != 0 &&
   475e4:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   475e8:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   475ec:	672e           	beqs 4761c <_Objects_Name_to_id_u32+0x4c>         	<== NOT EXECUTED
   475ee:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   475f2:	6630           	bnes 47624 <_Objects_Name_to_id_u32+0x54>         	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   475f4:	4281           	clrl %d1                                          	<== NOT EXECUTED
   475f6:	3200           	movew %d0,%d1                                     	<== NOT EXECUTED
   475f8:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   475fa:	6720           	beqs 4761c <_Objects_Name_to_id_u32+0x4c>         	<== NOT EXECUTED
  if ( name == 0 )
    return OBJECTS_INVALID_NAME;

  search_local_node = FALSE;

  if ( information->maximum != 0 &&
   475fc:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   47600:	2268 001a      	moveal %a0@(26),%a1                               	<== NOT EXECUTED
   47604:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47606:	5889           	addql #4,%a1                                      	<== NOT EXECUTED

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
      the_object = information->local_table[ index ];
   47608:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   4760a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4760c:	5889           	addql #4,%a1                                      	<== NOT EXECUTED
      the_object = information->local_table[ index ];
      if ( !the_object )
   4760e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47610:	6706           	beqs 47618 <_Objects_Name_to_id_u32+0x48>         	<== NOT EXECUTED
        continue;

      if ( name == the_object->name.name_u32 ) {
   47612:	b4a8 000c      	cmpl %a0@(12),%d2                                 	<== NOT EXECUTED
   47616:	6722           	beqs 4763a <_Objects_Name_to_id_u32+0x6a>         	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   47618:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4761a:	64ec           	bccs 47608 <_Objects_Name_to_id_u32+0x38>         	<== NOT EXECUTED
   4761c:	7001           	moveq #1,%d0                                      	<== 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
}
   4761e:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47620:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47622:	4e75           	rts                                               	<== NOT EXECUTED
  if ( name == 0 )
    return OBJECTS_INVALID_NAME;

  search_local_node = FALSE;

  if ( information->maximum != 0 &&
   47624:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
   47628:	b3fc 7fff ffff 	cmpal #2147483647,%a1                             	<== NOT EXECUTED
   4762e:	67c4           	beqs 475f4 <_Objects_Name_to_id_u32+0x24>         	<== NOT EXECUTED
   47630:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   47632:	b289           	cmpl %a1,%d1                                      	<== NOT EXECUTED
   47634:	67be           	beqs 475f4 <_Objects_Name_to_id_u32+0x24>         	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   47636:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47638:	60e4           	bras 4761e <_Objects_Name_to_id_u32+0x4e>         	<== NOT EXECUTED
      the_object = information->local_table[ index ];
      if ( !the_object )
        continue;

      if ( name == the_object->name.name_u32 ) {
        *id = the_object->id;
   4763a:	226e 0014      	moveal %fp@(20),%a1                               	<== 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
}
   4763e:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
      the_object = information->local_table[ index ];
      if ( !the_object )
        continue;

      if ( name == the_object->name.name_u32 ) {
        *id = the_object->id;
   47640:	22a8 0008      	movel %a0@(8),%a1@                                	<== 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
}
   47644:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      the_object = information->local_table[ index ];
      if ( !the_object )
        continue;

      if ( name == the_object->name.name_u32 ) {
        *id = the_object->id;
   47646:	4280           	clrl %d0                                          	<== 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
}
   47648:	4e75           	rts                                               	<== NOT EXECUTED
   4764a:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4764c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Name               name_for_mp;
#endif

  /* ASSERT: information->is_string == FALSE */

  if ( !id )
   4764e:	7002           	moveq #2,%d0                                      	<== 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
}
   47650:	4e75           	rts                                               	<== NOT EXECUTED
	...

000475a0 <_Objects_Namespace_remove>:

void _Objects_Namespace_remove(
  Objects_Information  *information,
  Objects_Control      *the_object
)
{
   475a0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   475a4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  /*
   *  If this is a string format name, then free the memory.
   */
  if ( information->is_string && the_object->name.name_p )
   475a6:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

void _Objects_Namespace_remove(
  Objects_Information  *information,
  Objects_Control      *the_object
)
{
   475aa:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  /*
   *  If this is a string format name, then free the memory.
   */
  if ( information->is_string && the_object->name.name_p )
   475ae:	4a28 0034      	tstb %a0@(52)                                     	<== NOT EXECUTED
   475b2:	6710           	beqs 475c4 <_Objects_Namespace_remove+0x24>       	<== NOT EXECUTED
   475b4:	202a 000c      	movel %a2@(12),%d0                                	<== NOT EXECUTED
   475b8:	670a           	beqs 475c4 <_Objects_Namespace_remove+0x24>       	<== NOT EXECUTED
     _Workspace_Free( (void *)the_object->name.name_p );
   475ba:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   475bc:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   475c2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  /*
   * Clear out either format.
   */
  the_object->name.name_p   = NULL;
  the_object->name.name_u32 = 0;
   475c4:	42aa 000c      	clrl %a2@(12)                                     	<== NOT EXECUTED
}
   475c8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   475cc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   475ce:	4e75           	rts

00049240 <_Objects_Set_name>:
bool _Objects_Set_name(
  Objects_Information *information,
  Objects_Control     *the_object,
  const char          *name
)
{
   49240:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   49244:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   49248:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   4924c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4924e:	302a 0036      	movew %a2@(54),%d0                                	<== NOT EXECUTED
   49252:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
bool _Objects_Set_name(
  Objects_Information *information,
  Objects_Control     *the_object,
  const char          *name
)
{
   49254:	266e 0010      	moveal %fp@(16),%a3                               	<== NOT EXECUTED
   49258:	286e 000c      	moveal %fp@(12),%a4                               	<== NOT EXECUTED
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   4925c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4925e:	4eb9 0004 fbcc 	jsr 4fbcc <strnlen>                               	<== NOT EXECUTED
   49264:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED

  if ( information->is_string ) {
   49266:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   49268:	5282           	addql #1,%d2                                      	<== NOT EXECUTED

  if ( information->is_string ) {
   4926a:	4a2a 0034      	tstb %a2@(52)                                     	<== NOT EXECUTED
   4926e:	6656           	bnes 492c6 <_Objects_Set_name+0x86>               	<== NOT EXECUTED

    strncpy( d, name, length );
    d[ length ] = '\0';
    the_object->name.name_p = d;
  } else {
    the_object->name.name_u32 =  _Objects_Build_name(
   49270:	223c 2020 2020 	movel #538976288,%d1                              	<== NOT EXECUTED
   49276:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   49278:	673c           	beqs 492b6 <_Objects_Set_name+0x76>               	<== NOT EXECUTED
   4927a:	1013           	moveb %a3@,%d0                                    	<== NOT EXECUTED
   4927c:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   4927e:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   49280:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   49282:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   49286:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   49288:	6700 00b0      	beqw 4933a <_Objects_Set_name+0xfa>               	<== NOT EXECUTED
   4928c:	122b 0001      	moveb %a3@(1),%d1                                 	<== NOT EXECUTED
   49290:	49c1           	extbl %d1                                         	<== NOT EXECUTED
   49292:	4841           	swap %d1                                          	<== NOT EXECUTED
   49294:	4241           	clrw %d1                                          	<== NOT EXECUTED
   49296:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   49298:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4929a:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4929c:	6774           	beqs 49312 <_Objects_Set_name+0xd2>               	<== NOT EXECUTED
   4929e:	102b 0002      	moveb %a3@(2),%d0                                 	<== NOT EXECUTED
   492a2:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   492a4:	e188           	lsll #8,%d0                                       	<== NOT EXECUTED
   492a6:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   492a8:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   492aa:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   492ac:	677e           	beqs 4932c <_Objects_Set_name+0xec>               	<== NOT EXECUTED
   492ae:	102b 0003      	moveb %a3@(3),%d0                                 	<== NOT EXECUTED
   492b2:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   492b4:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   492b6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   492b8:	2941 000c      	movel %d1,%a4@(12)                                	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   492bc:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   492c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   492c4:	4e75           	rts                                               	<== NOT EXECUTED
  length = strnlen( name, information->name_length ) + 1;

  if ( information->is_string ) {
    char *d;

    d = _Workspace_Allocate( length );
   492c6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   492c8:	4eb9 0004 ae48 	jsr 4ae48 <_Workspace_Allocate>                   	<== NOT EXECUTED
    if ( !d )
   492ce:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  length = strnlen( name, information->name_length ) + 1;

  if ( information->is_string ) {
    char *d;

    d = _Workspace_Allocate( length );
   492d0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
    if ( !d )
   492d2:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   492d4:	674a           	beqs 49320 <_Objects_Set_name+0xe0>               	<== NOT EXECUTED
      return FALSE;

    if ( the_object->name.name_p ) {
   492d6:	202c 000c      	movel %a4@(12),%d0                                	<== NOT EXECUTED
   492da:	670e           	beqs 492ea <_Objects_Set_name+0xaa>               	<== NOT EXECUTED
      _Workspace_Free( (void *)the_object->name.name_p );
   492dc:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   492de:	4eb9 0004 ae30 	jsr 4ae30 <_Workspace_Free>                       	<== NOT EXECUTED
      the_object->name.name_p = NULL;
   492e4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   492e6:	42ac 000c      	clrl %a4@(12)                                     	<== NOT EXECUTED
    }

    strncpy( d, name, length );
   492ea:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   492ec:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   492ee:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   492f0:	4eb9 0004 fb40 	jsr 4fb40 <strncpy>                               	<== NOT EXECUTED
    d[ length ] = '\0';
   492f6:	4200           	clrb %d0                                          	<== NOT EXECUTED
   492f8:	1580 2800      	moveb %d0,%a2@(00000000,%d2:l)                    	<== NOT EXECUTED
    the_object->name.name_p = d;
   492fc:	294a 000c      	movel %a2,%a4@(12)                                	<== NOT EXECUTED
   49300:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   49306:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   4930c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      the_object->name.name_p = NULL;
    }

    strncpy( d, name, length );
    d[ length ] = '\0';
    the_object->name.name_p = d;
   4930e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   49310:	4e75           	rts                                               	<== NOT EXECUTED

    strncpy( d, name, length );
    d[ length ] = '\0';
    the_object->name.name_p = d;
  } else {
    the_object->name.name_u32 =  _Objects_Build_name(
   49312:	0081 0000 2020 	oril #8224,%d1                                    	<== NOT EXECUTED
   49318:	2941 000c      	movel %d1,%a4@(12)                                	<== NOT EXECUTED
   4931c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4931e:	609c           	bras 492bc <_Objects_Set_name+0x7c>               	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   49320:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   49326:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( information->is_string ) {
    char *d;

    d = _Workspace_Allocate( length );
    if ( !d )
   49328:	4200           	clrb %d0                                          	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   4932a:	4e75           	rts                                               	<== NOT EXECUTED

    strncpy( d, name, length );
    d[ length ] = '\0';
    the_object->name.name_p = d;
  } else {
    the_object->name.name_u32 =  _Objects_Build_name(
   4932c:	103c 0020      	moveb #32,%d0                                     	<== NOT EXECUTED
   49330:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   49332:	2941 000c      	movel %d1,%a4@(12)                                	<== NOT EXECUTED
   49336:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49338:	6082           	bras 492bc <_Objects_Set_name+0x7c>               	<== NOT EXECUTED
   4933a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4933c:	0081 0020 2020 	oril #2105376,%d1                                 	<== NOT EXECUTED
   49342:	2941 000c      	movel %d1,%a4@(12)                                	<== NOT EXECUTED
   49346:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49348:	6000 ff72      	braw 492bc <_Objects_Set_name+0x7c>               	<== NOT EXECUTED

0004765c <_Objects_Shrink_information>:
 */

void _Objects_Shrink_information(
  Objects_Information *information
)
{
   4765c:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   47660:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   47664:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index(
  Objects_Id id
)
{
  return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS;
   47668:	2a2b 0006      	movel %a3@(6),%d5                                 	<== 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;
   4766c:	282b 0012      	movel %a3@(18),%d4                                	<== NOT EXECUTED
   47670:	4282           	clrl %d2                                          	<== NOT EXECUTED
   47672:	0285 0000 ffff 	andil #65535,%d5                                  	<== NOT EXECUTED
   47678:	342b 000e      	movew %a3@(14),%d2                                	<== NOT EXECUTED
   4767c:	9485           	subl %d5,%d2                                      	<== NOT EXECUTED
   4767e:	4c44 2002      	remul %d4,%d2,%d2                                 	<== NOT EXECUTED

  for ( block = 0; block < block_count; block++ ) {
   47682:	672c           	beqs 476b0 <_Objects_Shrink_information+0x54>     	<== NOT EXECUTED
    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
   47684:	206b 002c      	moveal %a3@(44),%a0                               	<== NOT EXECUTED
   47688:	b890           	cmpl %a0@,%d4                                     	<== NOT EXECUTED
   4768a:	672e           	beqs 476ba <_Objects_Shrink_information+0x5e>     	<== NOT EXECUTED
      information->object_blocks[ block ] = NULL;
      information->inactive_per_block[ block ] = 0;

      information->inactive -= information->allocation_size;

      return;
   4768c:	7604           	moveq #4,%d3                                      	<== NOT EXECUTED
   4768e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    }

    index_base += information->allocation_size;
   47690:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
   47692:	da84           	addl %d4,%d5                                      	<== NOT EXECUTED
   47694:	5881           	addql #4,%d1                                      	<== 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++ ) {
   47696:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47698:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4769a:	6414           	bccs 476b0 <_Objects_Shrink_information+0x54>     	<== NOT EXECUTED
    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
   4769c:	b8b0 3800      	cmpl %a0@(00000000,%d3:l),%d4                     	<== NOT EXECUTED
   476a0:	671a           	beqs 476bc <_Objects_Shrink_information+0x60>     	<== NOT EXECUTED
   476a2:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
      information->inactive -= information->allocation_size;

      return;
    }

    index_base += information->allocation_size;
   476a4:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
   476a6:	da84           	addl %d4,%d5                                      	<== NOT EXECUTED
   476a8:	5881           	addql #4,%d1                                      	<== 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++ ) {
   476aa:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   476ac:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   476ae:	65ec           	bcss 4769c <_Objects_Shrink_information+0x40>     	<== NOT EXECUTED
      return;
    }

    index_base += information->allocation_size;
  }
}
   476b0:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   476b6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   476b8:	4e75           	rts                                               	<== NOT EXECUTED

  index_base = _Objects_Get_index( information->minimum_id );
  block_count = ( information->maximum - index_base ) / information->allocation_size;

  for ( block = 0; block < block_count; block++ ) {
    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
   476ba:	4283           	clrl %d3                                          	<== 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;
   476bc:	206b 001e      	moveal %a3@(30),%a0                               	<== 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 );
   476c0:	49f9 0004 b1cc 	lea 4b1cc <_Chain_Extract>,%a4                    	<== NOT EXECUTED
   476c6:	2228 0008      	movel %a0@(8),%d1                                 	<== NOT EXECUTED
   476ca:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
       */

      do {
        index = _Objects_Get_index( the_object->id );

        if ((index >= index_base) &&
   476d0:	ba81           	cmpl %d1,%d5                                      	<== NOT EXECUTED
   476d2:	6252           	bhis 47726 <_Objects_Shrink_information+0xca>     	<== NOT EXECUTED
   476d4:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   476d6:	d0ab 0012      	addl %a3@(18),%d0                                 	<== NOT EXECUTED
   476da:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   476dc:	6448           	bccs 47726 <_Objects_Shrink_information+0xca>     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_last(
  const Chain_Node *the_node
)
{
  return (the_node->next == NULL);
   476de:	2450           	moveal %a0@,%a2                                   	<== 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 );
   476e0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   476e2:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   476e4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        }
        else {
          the_object = (Objects_Control *) the_object->Node.next;
        }
      }
      while ( the_object && !_Chain_Is_last( &the_object->Node ) );
   476e6:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   476e8:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   476ea:	6704           	beqs 476f0 <_Objects_Shrink_information+0x94>     	<== NOT EXECUTED
   476ec:	4a92           	tstl %a2@                                         	<== NOT EXECUTED
   476ee:	66d6           	bnes 476c6 <_Objects_Shrink_information+0x6a>     	<== NOT EXECUTED

      /*
       *  Free the memory and reset the structures in the object' information
       */

      _Workspace_Free( information->object_blocks[ block ] );
   476f0:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
   476f4:	2f30 3800      	movel %a0@(00000000,%d3:l),%sp@-                  	<== NOT EXECUTED
   476f8:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
      information->object_blocks[ block ] = NULL;
      information->inactive_per_block[ block ] = 0;
   476fe:	206b 002c      	moveal %a3@(44),%a0                               	<== NOT EXECUTED
   47702:	42b0 3800      	clrl %a0@(00000000,%d3:l)                         	<== NOT EXECUTED

      information->inactive -= information->allocation_size;
   47706:	302b 002a      	movew %a3@(42),%d0                                	<== NOT EXECUTED
   4770a:	90ab 0012      	subl %a3@(18),%d0                                 	<== NOT EXECUTED
      /*
       *  Free the memory and reset the structures in the object' information
       */

      _Workspace_Free( information->object_blocks[ block ] );
      information->object_blocks[ block ] = NULL;
   4770e:	226b 0030      	moveal %a3@(48),%a1                               	<== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;

      information->inactive -= information->allocation_size;
   47712:	3740 002a      	movew %d0,%a3@(42)                                	<== NOT EXECUTED
      /*
       *  Free the memory and reset the structures in the object' information
       */

      _Workspace_Free( information->object_blocks[ block ] );
      information->object_blocks[ block ] = NULL;
   47716:	42b1 3800      	clrl %a1@(00000000,%d3:l)                         	<== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;

      information->inactive -= information->allocation_size;
   4771a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      return;
    }

    index_base += information->allocation_size;
  }
}
   4771c:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   47722:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47724:	4e75           	rts                                               	<== NOT EXECUTED
            the_object = NULL;

          _Chain_Extract( &extract_me->Node );
        }
        else {
          the_object = (Objects_Control *) the_object->Node.next;
   47726:	2450           	moveal %a0@,%a2                                   	<== NOT EXECUTED
   47728:	60bc           	bras 476e6 <_Objects_Shrink_information+0x8a>     	<== NOT EXECUTED
	...

0004adc4 <_Partition_Manager_initialization>:
 */

void _Partition_Manager_initialization(
  uint32_t   maximum_partitions
)
{
   4adc4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4adc8:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4adcc:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4adce:	4878 0030      	pea 30 <OPER2+0x1c>                               	<== NOT EXECUTED
   4add2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4add6:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   4adda:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4adde:	4879 0005 8a8a 	pea 58a8a <_Partition_Information>                	<== NOT EXECUTED
   4ade4:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4adea:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_PARTITION,
    _Partition_MP_Process_packet
  );
#endif

}
   4adf0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4adf2:	4e75           	rts

0004b690 <_Protected_heap_Allocate>:

void *_Protected_heap_Allocate(
  Heap_Control *the_heap,
  size_t        size
)
{
   4b690:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b694:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  void *p;

  _RTEMS_Lock_allocator();
   4b696:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4b69c:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    p = _Heap_Allocate( the_heap, size );
   4b6a2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4b6a6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4b6aa:	4eb9 0004 b404 	jsr 4b404 <_Heap_Allocate>                        	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4b6b0:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  void *p;

  _RTEMS_Lock_allocator();
    p = _Heap_Allocate( the_heap, size );
   4b6b6:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4b6b8:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return p;
}
   4b6be:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4b6c0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b6c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b6c6:	4e75           	rts

0004ac8c <_Protected_heap_Allocate_aligned>:
void *_Protected_heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   4ac8c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4ac90:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  void *p;

  _RTEMS_Lock_allocator();
   4ac92:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4ac98:	4eb9 0004 955c 	jsr 4955c <_API_Mutex_Lock>                       	<== NOT EXECUTED
    p = _Heap_Allocate_aligned( the_heap, size, alignment );
   4ac9e:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4aca2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4aca6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4acaa:	4eb9 0004 9c40 	jsr 49c40 <_Heap_Allocate_aligned>                	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4acb0:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  void *p;

  _RTEMS_Lock_allocator();
    p = _Heap_Allocate_aligned( the_heap, size, alignment );
   4acb6:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4acb8:	4eb9 0004 95c0 	jsr 495c0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return p;
}
   4acbe:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4acc0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4acc4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4acc6:	4e75           	rts

0004ad00 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
  Heap_Control *the_heap,
  void         *starting_address,
  size_t        size
)
{
   4ad00:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4ad04:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Heap_Extend_status status;
  uint32_t           amount_extended;

  _RTEMS_Lock_allocator();
   4ad06:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4ad0c:	4eb9 0004 955c 	jsr 4955c <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
   4ad12:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4ad16:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4ad1a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4ad1e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ad22:	4eb9 0004 ea54 	jsr 4ea54 <_Heap_Extend>                          	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4ad28:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
{
  Heap_Extend_status status;
  uint32_t           amount_extended;

  _RTEMS_Lock_allocator();
    status = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
   4ad2e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4ad30:	4eb9 0004 95c0 	jsr 495c0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4ad36:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4ad38:	57c0           	seq %d0                                           	<== NOT EXECUTED
  return (status == HEAP_EXTEND_SUCCESSFUL);
}
   4ad3a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
  Heap_Extend_status status;
  uint32_t           amount_extended;

  _RTEMS_Lock_allocator();
    status = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
  _RTEMS_Unlock_allocator();
   4ad3e:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
  return (status == HEAP_EXTEND_SUCCESSFUL);
}
   4ad44:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ad46:	4480           	negl %d0                                          	<== NOT EXECUTED
   4ad48:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b6c8 <_Protected_heap_Free>:

bool _Protected_heap_Free(
  Heap_Control *the_heap,
  void         *start_address
)
{
   4b6c8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b6cc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  bool    status;

  _RTEMS_Lock_allocator();
   4b6ce:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4b6d4:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Free( the_heap, start_address );
   4b6da:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4b6de:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4b6e2:	4eb9 0004 b4c8 	jsr 4b4c8 <_Heap_Free>                            	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4b6e8:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  bool    status;

  _RTEMS_Lock_allocator();
    status = _Heap_Free( the_heap, start_address );
   4b6ee:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4b6f0:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return status;
}
   4b6f6:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   4b6f8:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   4b6fc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b6fe:	4e75           	rts

000550fc <_Protected_heap_Get_block_size>:
bool _Protected_heap_Get_block_size(
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t              *size
)
{
   550fc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   55100:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  bool    status;

  _RTEMS_Lock_allocator();
   55102:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   55108:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Size_of_user_area( the_heap, starting_address, size );
   5510e:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   55112:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   55116:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5511a:	4eb9 0005 534c 	jsr 5534c <_Heap_Size_of_user_area>               	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   55120:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  bool    status;

  _RTEMS_Lock_allocator();
    status = _Heap_Size_of_user_area( the_heap, starting_address, size );
   55126:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   55128:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return status;
}
   5512e:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   55130:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   55134:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   55136:	4e75           	rts

0004bf94 <_Protected_heap_Get_free_information>:

bool _Protected_heap_Get_free_information(
  Heap_Control        *the_heap,
  Heap_Information    *info
)
{
   4bf94:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  /*
   * TBD: _Heap_Get_free_information does not error check or return status.
   */

  _RTEMS_Lock_allocator();
   4bf98:	2f39 0009 9f36 	movel 99f36 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4bf9e:	4eb9 0004 ace0 	jsr 4ace0 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    _Heap_Get_free_information( the_heap, info );
   4bfa4:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4bfa8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4bfac:	4eb9 0006 36c4 	jsr 636c4 <_Heap_Get_free_information>            	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4bfb2:	2f39 0009 9f36 	movel 99f36 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4bfb8:	4eb9 0004 ad44 	jsr 4ad44 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

  return true;
}
   4bfbe:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bfc0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4bfc2:	4e75           	rts

00063840 <_Protected_heap_Get_information>:

bool _Protected_heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
   63840:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   63844:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   63846:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   6384a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6384c:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Heap_Get_information_status status;

  if ( !the_heap )
   63850:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   63852:	6740           	beqs 63894 <_Protected_heap_Get_information+0x54> 	<== NOT EXECUTED
    return false;

  if ( !the_info )
   63854:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   63856:	673c           	beqs 63894 <_Protected_heap_Get_information+0x54> 	<== NOT EXECUTED
    return false;

  _RTEMS_Lock_allocator();
   63858:	2f39 0009 9f36 	movel 99f36 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   6385e:	4eb9 0004 ace0 	jsr 4ace0 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Get_information( the_heap, the_info );
   63864:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   63866:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   63868:	4eb9 0006 dd74 	jsr 6dd74 <_Heap_Get_information>                 	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   6386e:	2f39 0009 9f36 	movel 99f36 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

  if ( !the_info )
    return false;

  _RTEMS_Lock_allocator();
    status = _Heap_Get_information( the_heap, the_info );
   63874:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   63876:	4eb9 0004 ad44 	jsr 4ad44 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
   6387c:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   6387e:	57c0           	seq %d0                                           	<== NOT EXECUTED
    return true;

  return false;
}
   63880:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   63884:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED

  _RTEMS_Lock_allocator();
    status = _Heap_Get_information( the_heap, the_info );
  _RTEMS_Unlock_allocator();

  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
   63888:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    return true;

  return false;
}
   6388e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  _RTEMS_Lock_allocator();
    status = _Heap_Get_information( the_heap, the_info );
  _RTEMS_Unlock_allocator();

  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
   63890:	4480           	negl %d0                                          	<== NOT EXECUTED
    return true;

  return false;
}
   63892:	4e75           	rts                                               	<== NOT EXECUTED
   63894:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   63898:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   6389c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  _RTEMS_Lock_allocator();
    status = _Heap_Get_information( the_heap, the_info );
  _RTEMS_Unlock_allocator();

  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
   6389e:	4200           	clrb %d0                                          	<== NOT EXECUTED
    return true;

  return false;
}
   638a0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00055138 <_Protected_heap_Resize_block>:
bool _Protected_heap_Resize_block(
  Heap_Control *the_heap,
  void         *starting_address,
  size_t        size
)
{
   55138:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   5513c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Heap_Resize_status status;
  uint32_t           old_mem_size;
  uint32_t           avail_mem_size;

  _RTEMS_Lock_allocator();
   5513e:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   55144:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Resize_block(
   5514a:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   5514e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   55152:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   55156:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   5515a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5515e:	4eb9 0005 5188 	jsr 55188 <_Heap_Resize_block>                    	<== NOT EXECUTED
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();
   55164:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
  Heap_Resize_status status;
  uint32_t           old_mem_size;
  uint32_t           avail_mem_size;

  _RTEMS_Lock_allocator();
    status = _Heap_Resize_block(
   5516a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();
   5516c:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   55172:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   55174:	57c0           	seq %d0                                           	<== NOT EXECUTED
  return (status == HEAP_RESIZE_SUCCESSFUL);
}
   55176:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
  uint32_t           avail_mem_size;

  _RTEMS_Lock_allocator();
    status = _Heap_Resize_block(
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();
   5517a:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
  return (status == HEAP_RESIZE_SUCCESSFUL);
}
   55180:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   55182:	4480           	negl %d0                                          	<== NOT EXECUTED
   55184:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004aea4 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
  Heap_Control *the_heap,
  int           source,
  bool          do_dump
)
{
   4aea4:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4aea8:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   4aeac:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   4aeb0:	262e 000c      	movel %fp@(12),%d3                                	<== 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 ) {
   4aeb4:	2039 0005 c798 	movel 5c798 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
bool _Protected_heap_Walk(
  Heap_Control *the_heap,
  int           source,
  bool          do_dump
)
{
   4aeba:	142e 0013      	moveb %fp@(19),%d2                                	<== 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 ) {
   4aebe:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4aec0:	671e           	beqs 4aee0 <_Protected_heap_Walk+0x3c>            	<== NOT EXECUTED
    _RTEMS_Lock_allocator();
      status = _Heap_Walk( the_heap, source, do_dump );
    _RTEMS_Unlock_allocator();
  } else {
    status = _Heap_Walk( the_heap, source, do_dump );
   4aec2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4aec4:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   4aec6:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4aeca:	2d44 0008      	movel %d4,%fp@(8)                                 	<== NOT EXECUTED
  }
  return status;
}
   4aece:	4cee 001c fff4 	moveml %fp@(-12),%d2-%d4                          	<== 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 );
   4aed4:	2d40 0010      	movel %d0,%fp@(16)                                	<== NOT EXECUTED
  }
  return status;
}
   4aed8:	4e5e           	unlk %fp                                          	<== 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 );
   4aeda:	4ef9 0004 ec44 	jmp 4ec44 <_Heap_Walk>                            	<== NOT EXECUTED
   * a critical section, it should be safe to walk it unlocked.
   *
   * NOTE: Dispatching is also disabled during initialization.
   */
  if ( !_Thread_Dispatch_disable_level ) {
    _RTEMS_Lock_allocator();
   4aee0:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4aee6:	4eb9 0004 955c 	jsr 4955c <_API_Mutex_Lock>                       	<== NOT EXECUTED
      status = _Heap_Walk( the_heap, source, do_dump );
   4aeec:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4aeee:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   4aef0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4aef2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4aef4:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4aef6:	4eb9 0004 ec44 	jsr 4ec44 <_Heap_Walk>                            	<== NOT EXECUTED
    _RTEMS_Unlock_allocator();
   4aefc:	2f39 0005 c84e 	movel 5c84e <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   *
   * NOTE: Dispatching is also disabled during initialization.
   */
  if ( !_Thread_Dispatch_disable_level ) {
    _RTEMS_Lock_allocator();
      status = _Heap_Walk( the_heap, source, do_dump );
   4af02:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
    _RTEMS_Unlock_allocator();
   4af04:	4eb9 0004 95c0 	jsr 495c0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  } else {
    status = _Heap_Walk( the_heap, source, do_dump );
  }
  return status;
}
   4af0a:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   * NOTE: Dispatching is also disabled during initialization.
   */
  if ( !_Thread_Dispatch_disable_level ) {
    _RTEMS_Lock_allocator();
      status = _Heap_Walk( the_heap, source, do_dump );
    _RTEMS_Unlock_allocator();
   4af0c:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
  } else {
    status = _Heap_Walk( the_heap, source, do_dump );
  }
  return status;
}
   4af12:	4cee 001c fff4 	moveml %fp@(-12),%d2-%d4                          	<== NOT EXECUTED
   4af18:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4af1a:	4e75           	rts

00046470 <_RTEMS_API_Initialize>:
 */

void _RTEMS_API_Initialize(
  rtems_configuration_table *configuration_table
)
{
   46470:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46474:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   46478:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  rtems_api_configuration_table *api_configuration;

  api_configuration = configuration_table->RTEMS_api_configuration;
   4647a:	2468 003e      	moveal %a0@(62),%a2                               	<== NOT EXECUTED

  _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects;
   4647e:	203c 0005 890a 	movel #362762,%d0                                 	<== NOT EXECUTED
   46484:	23c0 0005 8714 	movel %d0,58714 <_Objects_Information_table+0x8>  	<== NOT EXECUTED

  _Attributes_Handler_initialization();

  _Interrupt_Manager_initialization();
   4648a:	4eb9 0004 ad8c 	jsr 4ad8c <_Interrupt_Manager_initialization>     	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  _Multiprocessing_Manager_initialization();
#endif

  _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks );
   46490:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   46492:	4eb9 0004 af36 	jsr 4af36 <_RTEMS_tasks_Manager_initialization>   	<== NOT EXECUTED

  _Timer_Manager_initialization( api_configuration->maximum_timers );
   46498:	2f2a 0006      	movel %a2@(6),%sp@-                               	<== NOT EXECUTED
   4649c:	4eb9 0004 ae54 	jsr 4ae54 <_Timer_Manager_initialization>         	<== NOT EXECUTED

  _Signal_Manager_initialization();
   464a2:	4eb9 0004 aec0 	jsr 4aec0 <_Signal_Manager_initialization>        	<== NOT EXECUTED

  _Event_Manager_initialization();
   464a8:	4eb9 0004 ad7c 	jsr 4ad7c <_Event_Manager_initialization>         	<== NOT EXECUTED

  _Message_queue_Manager_initialization(
   464ae:	2f2a 000e      	movel %a2@(14),%sp@-                              	<== NOT EXECUTED
   464b2:	4eb9 0004 ad94 	jsr 4ad94 <_Message_queue_Manager_initialization> 	<== NOT EXECUTED
    api_configuration->maximum_message_queues
  );

  _Semaphore_Manager_initialization( api_configuration->maximum_semaphores );
   464b8:	2f2a 000a      	movel %a2@(10),%sp@-                              	<== NOT EXECUTED
   464bc:	4eb9 0004 ae90 	jsr 4ae90 <_Semaphore_Manager_initialization>     	<== NOT EXECUTED

  _Partition_Manager_initialization( api_configuration->maximum_partitions );
   464c2:	2f2a 0012      	movel %a2@(18),%sp@-                              	<== NOT EXECUTED
   464c6:	4eb9 0004 adc4 	jsr 4adc4 <_Partition_Manager_initialization>     	<== NOT EXECUTED

  _Region_Manager_initialization( api_configuration->maximum_regions );
   464cc:	2f2a 0016      	movel %a2@(22),%sp@-                              	<== NOT EXECUTED
   464d0:	4eb9 0004 ae24 	jsr 4ae24 <_Region_Manager_initialization>        	<== NOT EXECUTED

  _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports);
   464d6:	2f2a 001a      	movel %a2@(26),%sp@-                              	<== NOT EXECUTED
   464da:	4eb9 0004 ad4c 	jsr 4ad4c <_Dual_ported_memory_Manager_initialization>	<== NOT EXECUTED

  _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods );
   464e0:	2f2a 001e      	movel %a2@(30),%sp@-                              	<== NOT EXECUTED
   464e4:	4eb9 0004 adf4 	jsr 4adf4 <_Rate_monotonic_Manager_initialization>	<== NOT EXECUTED

  _Barrier_Manager_initialization( api_configuration->maximum_barriers );
   464ea:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   464f0:	2d6a 0022 0008 	movel %a2@(34),%fp@(8)                            	<== NOT EXECUTED
}
   464f6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   464fa:	4e5e           	unlk %fp                                          	<== 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 );
   464fc:	4ef9 0004 ad1c 	jmp 4ad1c <_Barrier_Manager_initialization>       	<== NOT EXECUTED
	...

0004b0e8 <_RTEMS_Tasks_Invoke_task_variable_dtor>:

void _RTEMS_Tasks_Invoke_task_variable_dtor(
  Thread_Control        *the_thread,
  rtems_task_variable_t *tvp
)
{
   4b0e8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b0ec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b0ee:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  void (*dtor)(void *);
  void *value;

  dtor = tvp->dtor;
  if (_Thread_Is_executing(the_thread)) {
   4b0f2:	2039 0005 8812 	movel 58812 <_Thread_Executing>,%d0               	<== NOT EXECUTED
)
{
  void (*dtor)(void *);
  void *value;

  dtor = tvp->dtor;
   4b0f8:	226a 0010      	moveal %a2@(16),%a1                               	<== NOT EXECUTED
  if (_Thread_Is_executing(the_thread)) {
   4b0fc:	b0ae 0008      	cmpl %fp@(8),%d0                                  	<== NOT EXECUTED
   4b100:	671e           	beqs 4b120 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x38>	<== NOT EXECUTED
    value = *tvp->ptr;
    *tvp->ptr = tvp->gval;
  } else {
    value = tvp->tval;
   4b102:	202a 000c      	movel %a2@(12),%d0                                	<== NOT EXECUTED
  }

  if ( dtor )
   4b106:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4b108:	6706           	beqs 4b110 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x28>	<== NOT EXECUTED
    (*dtor)(value);
   4b10a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4b10c:	4e91           	jsr %a1@                                          	<== NOT EXECUTED
   4b10e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  _Workspace_Free(tvp);
   4b110:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
}
   4b114:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4b118:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  if ( dtor )
    (*dtor)(value);

  _Workspace_Free(tvp);
   4b11a:	4ef9 0004 9140 	jmp 49140 <_Workspace_Free>                       	<== NOT EXECUTED
  void (*dtor)(void *);
  void *value;

  dtor = tvp->dtor;
  if (_Thread_Is_executing(the_thread)) {
    value = *tvp->ptr;
   4b120:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
   4b124:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
   4b126:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   4b12a:	60da           	bras 4b106 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x1e>	<== NOT EXECUTED

0004b046 <_RTEMS_tasks_Create_extension>:
  /*
   *  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() )
   4b046:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED

bool _RTEMS_tasks_Create_extension(
  Thread_Control *executing,
  Thread_Control *created
)
{
   4b04c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b050:	2f0b           	movel %a3,%sp@-                                   	<== 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() )
   4b052:	2268 003e      	moveal %a0@(62),%a1                               	<== NOT EXECUTED

bool _RTEMS_tasks_Create_extension(
  Thread_Control *executing,
  Thread_Control *created
)
{
   4b056:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   4b05a:	2f0a           	movel %a2,%sp@-                                   	<== 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() )
   4b05c:	4a29 0004      	tstb %a1@(4)                                      	<== NOT EXECUTED
   4b060:	6664           	bnes 4b0c6 <_RTEMS_tasks_Create_extension+0x80>   	<== NOT EXECUTED
   4b062:	701e           	moveq #30,%d0                                     	<== NOT EXECUTED
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );
   4b064:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4b066:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED

  if ( !api )
   4b06c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   */
  to_allocate = sizeof( RTEMS_API_Control );
  if ( !rtems_configuration_get_notepads_enabled() )
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );
   4b06e:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( !api )
   4b070:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b072:	6764           	beqs 4b0d8 <_RTEMS_tasks_Create_extension+0x92>   	<== NOT EXECUTED

  api->pending_events = EVENT_SETS_NONE_PENDING;
  _ASR_Initialize( &api->Signal );
  created->task_variables = NULL;

  if ( rtems_configuration_get_notepads_enabled() ) {
   4b074:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   4b07a:	2268 003e      	moveal %a0@(62),%a1                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
   4b07e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

  created->API_Extensions[ THREAD_API_RTEMS ] = api;

  api->pending_events = EVENT_SETS_NONE_PENDING;
  _ASR_Initialize( &api->Signal );
  created->task_variables = NULL;
   4b080:	42ab 011c      	clrl %a3@(284)                                    	<== NOT EXECUTED
   4b084:	1540 0008      	moveb %d0,%a2@(8)                                 	<== NOT EXECUTED
  api = _Workspace_Allocate( to_allocate );

  if ( !api )
    return false;

  created->API_Extensions[ THREAD_API_RTEMS ] = api;
   4b088:	274a 010c      	movel %a2,%a3@(268)                               	<== NOT EXECUTED

  api->pending_events = EVENT_SETS_NONE_PENDING;
   4b08c:	4292           	clrl %a2@                                         	<== NOT EXECUTED
  information->handler         = NULL;
   4b08e:	42aa 000a      	clrl %a2@(10)                                     	<== NOT EXECUTED
  information->mode_set        = RTEMS_DEFAULT_MODES;
   4b092:	42aa 000e      	clrl %a2@(14)                                     	<== NOT EXECUTED
  information->signals_posted  = 0;
   4b096:	42aa 0012      	clrl %a2@(18)                                     	<== NOT EXECUTED
  information->signals_pending = 0;
   4b09a:	42aa 0016      	clrl %a2@(22)                                     	<== NOT EXECUTED
  information->nest_level      = 0;
   4b09e:	42aa 001a      	clrl %a2@(26)                                     	<== NOT EXECUTED
  _ASR_Initialize( &api->Signal );
  created->task_variables = NULL;

  if ( rtems_configuration_get_notepads_enabled() ) {
   4b0a2:	4a29 0004      	tstb %a1@(4)                                      	<== NOT EXECUTED
   4b0a6:	6710           	beqs 4b0b8 <_RTEMS_tasks_Create_extension+0x72>   	<== NOT EXECUTED
   4b0a8:	41ea 001e      	lea %a2@(30),%a0                                  	<== NOT EXECUTED
   4b0ac:	4280           	clrl %d0                                          	<== NOT EXECUTED
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
      api->Notepads[i] = 0;
   4b0ae:	4298           	clrl %a0@+                                        	<== 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++)
   4b0b0:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4b0b2:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   4b0b4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b0b6:	66f6           	bnes 4b0ae <_RTEMS_tasks_Create_extension+0x68>   	<== NOT EXECUTED
      api->Notepads[i] = 0;
  }

  return true;
}
   4b0b8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4b0bc:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4b0c0:	4e5e           	unlk %fp                                          	<== 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++)
   4b0c2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      api->Notepads[i] = 0;
  }

  return true;
}
   4b0c4:	4e75           	rts                                               	<== 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() )
   4b0c6:	705e           	moveq #94,%d0                                     	<== NOT EXECUTED
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );
   4b0c8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4b0ca:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED

  if ( !api )
   4b0d0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   */
  to_allocate = sizeof( RTEMS_API_Control );
  if ( !rtems_configuration_get_notepads_enabled() )
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );
   4b0d2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( !api )
   4b0d4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4b0d6:	669c           	bnes 4b074 <_RTEMS_tasks_Create_extension+0x2e>   	<== NOT EXECUTED
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
      api->Notepads[i] = 0;
  }

  return true;
}
   4b0d8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4b0dc:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4b0e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  if ( !rtems_configuration_get_notepads_enabled() )
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );

  if ( !api )
   4b0e2:	4200           	clrb %d0                                          	<== NOT EXECUTED
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
      api->Notepads[i] = 0;
  }

  return true;
}
   4b0e4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004affe <_RTEMS_tasks_Delete_extension>:

User_extensions_routine _RTEMS_tasks_Delete_extension(
  Thread_Control *executing,
  Thread_Control *deleted
)
{
   4affe:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4b002:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4b006:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED

  /*
   *  Free per task variable memory
   */

  tvp = deleted->task_variables;
   4b00a:	206a 011c      	moveal %a2@(284),%a0                              	<== NOT EXECUTED
  deleted->task_variables = NULL;
   4b00e:	42aa 011c      	clrl %a2@(284)                                    	<== NOT EXECUTED
  while (tvp) {
   4b012:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4b014:	6716           	beqs 4b02c <_RTEMS_tasks_Delete_extension+0x2e>   	<== NOT EXECUTED
   4b016:	47f9 0004 b0e8 	lea 4b0e8 <_RTEMS_Tasks_Invoke_task_variable_dtor>,%a3	<== NOT EXECUTED
    next = (rtems_task_variable_t *)tvp->next;
   4b01c:	2410           	movel %a0@,%d2                                    	<== NOT EXECUTED
    _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
   4b01e:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4b020:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b022:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4b024:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   *  Free per task variable memory
   */

  tvp = deleted->task_variables;
  deleted->task_variables = NULL;
  while (tvp) {
   4b026:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4b028:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4b02a:	66f0           	bnes 4b01c <_RTEMS_tasks_Delete_extension+0x1e>   	<== NOT EXECUTED

  /*
   *  Free API specific memory
   */

  (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
   4b02c:	2f2a 010c      	movel %a2@(268),%sp@-                             	<== NOT EXECUTED
   4b030:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
  deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
   4b036:	42aa 010c      	clrl %a2@(268)                                    	<== NOT EXECUTED
   4b03a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
}
   4b03c:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4b042:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b044:	4e75           	rts

0004af1e <_RTEMS_tasks_Initialize_user_tasks>:
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks( void )
{
  if ( _RTEMS_tasks_Initialize_user_tasks_p )
   4af1e:	2039 0005 6c8e 	movel 56c8e <_RTEMS_tasks_Initialize_user_tasks_p>,%d0	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks( void )
{
   4af24:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  if ( _RTEMS_tasks_Initialize_user_tasks_p )
   4af28:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4af2a:	6706           	beqs 4af32 <_RTEMS_tasks_Initialize_user_tasks+0x14>	<== NOT EXECUTED
    (*_RTEMS_tasks_Initialize_user_tasks_p)();
}
   4af2c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
 */

void _RTEMS_tasks_Initialize_user_tasks( void )
{
  if ( _RTEMS_tasks_Initialize_user_tasks_p )
    (*_RTEMS_tasks_Initialize_user_tasks_p)();
   4af2e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4af30:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4af32:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4af34:	4e75           	rts

00046010 <_RTEMS_tasks_Initialize_user_tasks_body>:
  rtems_status_code                 return_value;
  rtems_initialization_tasks_table *user_tasks;
  rtems_api_configuration_table    *api_configuration;


  api_configuration = _Configuration_Table->RTEMS_api_configuration;
   46010:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46016:	2268 003e      	moveal %a0@(62),%a1                               	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
   4601a:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4601e:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
  /*
   *  NOTE:  This is slightly different from the Ada implementation.
   */

  user_tasks = api_configuration->User_initialization_tasks_table;
  maximum    = api_configuration->number_of_initialization_tasks;
   46022:	2629 0026      	movel %a1@(38),%d3                                	<== NOT EXECUTED

  /*
   *  NOTE:  This is slightly different from the Ada implementation.
   */

  user_tasks = api_configuration->User_initialization_tasks_table;
   46026:	2029 002a      	movel %a1@(42),%d0                                	<== NOT EXECUTED
  maximum    = api_configuration->number_of_initialization_tasks;

  if ( !user_tasks || maximum == 0 )
   4602a:	675c           	beqs 46088 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>	<== NOT EXECUTED
   4602c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4602e:	6758           	beqs 46088 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>	<== NOT EXECUTED
   46030:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   46032:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   46034:	4282           	clrl %d2                                          	<== NOT EXECUTED
   46036:	5984           	subql #4,%d4                                      	<== NOT EXECUTED
   46038:	49f9 0004 5dd0 	lea 45dd0 <rtems_task_create>,%a4                 	<== NOT EXECUTED
    );

    if ( !rtems_is_status_successful( return_value ) )
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );

    return_value = rtems_task_start(
   4603e:	47f9 0004 60a4 	lea 460a4 <rtems_task_start>,%a3                  	<== NOT EXECUTED

  if ( !user_tasks || maximum == 0 )
    return;

  for ( index=0 ; index < maximum ; index++ ) {
    return_value = rtems_task_create(
   46044:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46046:	2f2a 000c      	movel %a2@(12),%sp@-                              	<== NOT EXECUTED
   4604a:	2f2a 0014      	movel %a2@(20),%sp@-                              	<== NOT EXECUTED
   4604e:	2f2a 0004      	movel %a2@(4),%sp@-                               	<== NOT EXECUTED
   46052:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   46056:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   46058:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
      user_tasks[ index ].mode_set,
      user_tasks[ index ].attribute_set,
      &id
    );

    if ( !rtems_is_status_successful( return_value ) )
   4605a:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   46060:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46062:	662e           	bnes 46092 <_RTEMS_tasks_Initialize_user_tasks_body+0x82>	<== NOT EXECUTED
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );

    return_value = rtems_task_start(
   46064:	2f2a 0018      	movel %a2@(24),%sp@-                              	<== NOT EXECUTED
   46068:	2f2a 0010      	movel %a2@(16),%sp@-                              	<== NOT EXECUTED
   4606c:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   46070:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
      id,
      user_tasks[ index ].entry_point,
      user_tasks[ index ].argument
    );

    if ( !rtems_is_status_successful( return_value ) )
   46072:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46078:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4607a:	6616           	bnes 46092 <_RTEMS_tasks_Initialize_user_tasks_body+0x82>	<== NOT EXECUTED
  maximum    = api_configuration->number_of_initialization_tasks;

  if ( !user_tasks || maximum == 0 )
    return;

  for ( index=0 ; index < maximum ; index++ ) {
   4607c:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   4607e:	d5fc 0000 001c 	addal #28,%a2                                     	<== NOT EXECUTED
   46084:	b483           	cmpl %d3,%d2                                      	<== NOT EXECUTED
   46086:	65bc           	bcss 46044 <_RTEMS_tasks_Initialize_user_tasks_body+0x34>	<== NOT EXECUTED
    );

    if ( !rtems_is_status_successful( return_value ) )
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
  }
}
   46088:	4cee 1c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   4608e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46090:	4e75           	rts                                               	<== NOT EXECUTED
      user_tasks[ index ].entry_point,
      user_tasks[ index ].argument
    );

    if ( !rtems_is_status_successful( return_value ) )
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
   46092:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46094:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46098:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4609c:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
	...

0004af36 <_RTEMS_tasks_Manager_initialization>:
 */

void _RTEMS_tasks_Manager_initialization(
  uint32_t                          maximum_tasks
)
{
   4af36:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED

  _Objects_Initialize_information(
   4af3a:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4af3e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4af40:	4878 0120      	pea 120 <FP_REGS_SAVED+0xe0>                      	<== NOT EXECUTED
   4af44:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4af48:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4af4c:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4af50:	4879 0005 86c4 	pea 586c4 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   4af56:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED

  /*
   *  Add all the extensions for this API
   */

  _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions );
   4af5c:	4879 0005 70cc 	pea 570cc <_RTEMS_tasks_User_extensions>          	<== NOT EXECUTED
   4af62:	4eb9 0004 bb34 	jsr 4bb34 <_User_extensions_Add_API_set>          	<== NOT EXECUTED

  _API_extensions_Add( &_RTEMS_tasks_API_extensions );
   4af68:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   4af6e:	203c 0005 70b8 	movel #356536,%d0                                 	<== NOT EXECUTED
   4af74:	2d40 0008      	movel %d0,%fp@(8)                                 	<== NOT EXECUTED
    MP_PACKET_TASKS,
    _RTEMS_tasks_MP_Process_packet
  );
#endif

}
   4af78:	4e5e           	unlk %fp                                          	<== 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 );
   4af7a:	4ef9 0004 65bc 	jmp 465bc <_API_extensions_Add>                   	<== NOT EXECUTED

0004af80 <_RTEMS_tasks_Post_switch_extension>:
 */

void _RTEMS_tasks_Post_switch_extension(
  Thread_Control *executing
)
{
   4af80:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4af84:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   4af88:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== 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 ];
   4af8c:	2668 010c      	moveal %a0@(268),%a3                              	<== NOT EXECUTED
  if ( !api )
   4af90:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4af92:	671a           	beqs 4afae <_RTEMS_tasks_Post_switch_extension+0x2e>	<== NOT EXECUTED
   *  Signal Processing
   */

  asr = &api->Signal;

  _ISR_Disable( level );
   4af94:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   4af9a:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4af9c:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4af9e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    signal_set = asr->signals_posted;
   4afa0:	262b 0012      	movel %a3@(18),%d3                                	<== NOT EXECUTED
    asr->signals_posted = 0;
   4afa4:	42ab 0012      	clrl %a3@(18)                                     	<== NOT EXECUTED
  _ISR_Enable( level );
   4afa8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED


  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
   4afaa:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4afac:	660a           	bnes 4afb8 <_RTEMS_tasks_Post_switch_extension+0x38>	<== NOT EXECUTED
  (*asr->handler)( signal_set );

  asr->nest_level -= 1;
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );

}
   4afae:	4cee 0c0c ffec 	moveml %fp@(-20),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   4afb4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4afb6:	4e75           	rts                                               	<== NOT EXECUTED


  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
    return;

  asr->nest_level += 1;
   4afb8:	52ab 001a      	addql #1,%a3@(26)                                 	<== NOT EXECUTED
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
   4afbc:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   4afbe:	5982           	subql #4,%d2                                      	<== NOT EXECUTED
   4afc0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4afc2:	45f9 0004 c094 	lea 4c094 <rtems_task_mode>,%a2                   	<== NOT EXECUTED
   4afc8:	2f3c 0000 ffff 	movel #65535,%sp@-                                	<== NOT EXECUTED
   4afce:	2f2b 000e      	movel %a3@(14),%sp@-                              	<== NOT EXECUTED
   4afd2:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

  (*asr->handler)( signal_set );
   4afd4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4afd6:	206b 000a      	moveal %a3@(10),%a0                               	<== NOT EXECUTED
   4afda:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

  asr->nest_level -= 1;
   4afdc:	53ab 001a      	subql #1,%a3@(26)                                 	<== NOT EXECUTED
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
   4afe0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4afe2:	2f3c 0000 ffff 	movel #65535,%sp@-                                	<== NOT EXECUTED
   4afe8:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   4afec:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4afee:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED

}
   4aff4:	4cee 0c0c ffec 	moveml %fp@(-20),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   4affa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4affc:	4e75           	rts

0004aec8 <_RTEMS_tasks_Start_extension>:

User_extensions_routine _RTEMS_tasks_Start_extension(
  Thread_Control *executing,
  Thread_Control *started
)
{
   4aec8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4aecc:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  RTEMS_API_Control *api;

  api = started->API_Extensions[ THREAD_API_RTEMS ];

  api->pending_events = EVENT_SETS_NONE_PENDING;
   4aed0:	2268 010c      	moveal %a0@(268),%a1                              	<== NOT EXECUTED
}
   4aed4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  RTEMS_API_Control *api;

  api = started->API_Extensions[ THREAD_API_RTEMS ];

  api->pending_events = EVENT_SETS_NONE_PENDING;
   4aed6:	4291           	clrl %a1@                                         	<== NOT EXECUTED
}
   4aed8:	4e75           	rts

0004aeda <_RTEMS_tasks_Switch_extension>:

void _RTEMS_tasks_Switch_extension(
  Thread_Control *executing,
  Thread_Control *heir
)
{
   4aeda:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4aede:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

  /*
   *  Per Task Variables
   */

  tvp = executing->task_variables;
   4aee2:	2268 011c      	moveal %a0@(284),%a1                              	<== NOT EXECUTED
  while (tvp) {
   4aee6:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4aee8:	6712           	beqs 4aefc <_RTEMS_tasks_Switch_extension+0x22>   	<== NOT EXECUTED
    tvp->tval = *tvp->ptr;
   4aeea:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
   4aeee:	2350 000c      	movel %a0@,%a1@(12)                               	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
   4aef2:	20a9 0008      	movel %a1@(8),%a0@                                	<== NOT EXECUTED
    tvp = (rtems_task_variable_t *)tvp->next;
   4aef6:	2251           	moveal %a1@,%a1                                   	<== NOT EXECUTED
  /*
   *  Per Task Variables
   */

  tvp = executing->task_variables;
  while (tvp) {
   4aef8:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4aefa:	66ee           	bnes 4aeea <_RTEMS_tasks_Switch_extension+0x10>   	<== NOT EXECUTED
    tvp->tval = *tvp->ptr;
    *tvp->ptr = tvp->gval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }

  tvp = heir->task_variables;
   4aefc:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   4af00:	2268 011c      	moveal %a0@(284),%a1                              	<== NOT EXECUTED
  while (tvp) {
   4af04:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4af06:	6712           	beqs 4af1a <_RTEMS_tasks_Switch_extension+0x40>   	<== NOT EXECUTED
    tvp->gval = *tvp->ptr;
   4af08:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
   4af0c:	2350 0008      	movel %a0@,%a1@(8)                                	<== NOT EXECUTED
    *tvp->ptr = tvp->tval;
   4af10:	20a9 000c      	movel %a1@(12),%a0@                               	<== NOT EXECUTED
    tvp = (rtems_task_variable_t *)tvp->next;
   4af14:	2251           	moveal %a1@,%a1                                   	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }

  tvp = heir->task_variables;
  while (tvp) {
   4af16:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4af18:	66ee           	bnes 4af08 <_RTEMS_tasks_Switch_extension+0x2e>   	<== NOT EXECUTED
    tvp->gval = *tvp->ptr;
    *tvp->ptr = tvp->tval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }
}
   4af1a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4af1c:	4e75           	rts

000469ac <_Rate_monotonic_Initiate_statistics>:
#endif

void _Rate_monotonic_Initiate_statistics(
  Rate_monotonic_Control *the_period
)
{
   469ac:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   469b0:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
   469b4:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  Thread_Control *owning_thread = the_period->owner;
   469b8:	246b 0050      	moveal %a3@(80),%a2                               	<== NOT EXECUTED
  #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
      defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)

    struct timespec  uptime;

    _TOD_Get_uptime( &uptime );
   469bc:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   469be:	5183           	subql #8,%d3                                      	<== NOT EXECUTED
   469c0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   469c2:	4eb9 0004 8518 	jsr 48518 <_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;
   469c8:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   469cc:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   469d0:	2740 0044      	movel %d0,%a3@(68)                                	<== NOT EXECUTED
   469d4:	2741 0048      	movel %d1,%a3@(72)                                	<== NOT EXECUTED
  #else
    the_period->time_at_period = _Watchdog_Ticks_since_boot;
  #endif

  the_period->owner_executed_at_period = owning_thread->cpu_time_used;
   469d8:	202a 0084      	movel %a2@(132),%d0                               	<== NOT EXECUTED
   469dc:	276a 0088 0040 	movel %a2@(136),%a3@(64)                          	<== 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) {
   469e2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    the_period->time_at_period = uptime;
  #else
    the_period->time_at_period = _Watchdog_Ticks_since_boot;
  #endif

  the_period->owner_executed_at_period = owning_thread->cpu_time_used;
   469e4:	2740 003c      	movel %d0,%a3@(60)                                	<== 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) {
   469e8:	b5f9 0005 b75e 	cmpal 5b75e <_Thread_Executing>,%a2               	<== NOT EXECUTED
   469ee:	670a           	beqs 469fa <_Rate_monotonic_Initiate_statistics+0x4e>	<== NOT EXECUTED
      );

      _Timespec_Add_to( &the_period->owner_executed_at_period, &ran );
    }
  #endif
}
   469f0:	4cee 0c0c ffe0 	moveml %fp@(-32),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   469f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   469f8:	4e75           	rts                                               	<== NOT EXECUTED

      /*
       *  Adjust the CPU time used to account for the time since last
       *  context switch.
       */
      _Timespec_Subtract(
   469fa:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   469fc:	0682 ffff fff0 	addil #-16,%d2                                    	<== NOT EXECUTED
   46a02:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46a04:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46a06:	4879 0005 b766 	pea 5b766 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   46a0c:	4eb9 0004 a7fc 	jsr 4a7fc <_Timespec_Subtract>                    	<== NOT EXECUTED
	&_Thread_Time_of_last_context_switch, &uptime, &ran
      );

      _Timespec_Add_to( &the_period->owner_executed_at_period, &ran );
   46a12:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46a14:	486b 003c      	pea %a3@(60)                                      	<== NOT EXECUTED
   46a18:	4eb9 0004 a6b8 	jsr 4a6b8 <_Timespec_Add_to>                      	<== NOT EXECUTED
   46a1e:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    }
  #endif
}
   46a24:	4cee 0c0c ffe0 	moveml %fp@(-32),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   46a2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46a2c:	4e75           	rts

0004adf4 <_Rate_monotonic_Manager_initialization>:
 */

void _Rate_monotonic_Manager_initialization(
  uint32_t   maximum_periods
)
{
   4adf4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4adf8:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4adfc:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4adfe:	4878 008c      	pea 8c <FP_REGS_SAVED+0x4c>                       	<== NOT EXECUTED
   4ae02:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ae06:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   4ae0a:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ae0e:	4879 0005 8ac6 	pea 58ac6 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   4ae14:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4ae1a:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                     /* TRUE if this is a global object class */
    NULL                       /* Proxy extraction support callout */
#endif
  );
}
   4ae20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ae22:	4e75           	rts

00047084 <_Rate_monotonic_Timeout>:

void _Rate_monotonic_Timeout(
  Objects_Id  id,
  void       *ignored
)
{
   47084:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   47088:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4708a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4708e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47092:	4879 0005 b598 	pea 5b598 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   47098:	4eb9 0004 8f20 	jsr 48f20 <_Objects_Get>                          	<== 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 ) {
   4709e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   470a4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   470a6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   470aa:	662c           	bnes 470d8 <_Rate_monotonic_Timeout+0x54>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_thread = the_period->owner;
   470ac:	206a 0050      	moveal %a2@(80),%a0                               	<== NOT EXECUTED
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
   470b0:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
   470b4:	0280 0000 4000 	andil #16384,%d0                                  	<== NOT EXECUTED
   470ba:	6624           	bnes 470e0 <_Rate_monotonic_Timeout+0x5c>         	<== NOT EXECUTED
        _Thread_Unblock( the_thread );

        _Rate_monotonic_Initiate_statistics( the_period );

        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
   470bc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   470be:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   470c2:	6768           	beqs 4712c <_Rate_monotonic_Timeout+0xa8>         	<== NOT EXECUTED

        _Rate_monotonic_Initiate_statistics( the_period );

        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else
        the_period->state = RATE_MONOTONIC_EXPIRED;
   470c4:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   470c6:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   470ca:	2039 0005 b6a0 	movel 5b6a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   470d0:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   470d2:	23c0 0005 b6a0 	movel %d0,5b6a0 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */
#endif
    case OBJECTS_ERROR:
      break;
  }
}
   470d8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   470dc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   470de:	4e75           	rts                                               	<== NOT EXECUTED
  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      the_thread = the_period->owner;
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
   470e0:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
   470e4:	b0a8 0020      	cmpl %a0@(32),%d0                                 	<== NOT EXECUTED
   470e8:	66d2           	bnes 470bc <_Rate_monotonic_Timeout+0x38>         	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   470ea:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   470f0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   470f2:	4eb9 0004 93cc 	jsr 493cc <_Thread_Clear_state>                   	<== NOT EXECUTED
            the_thread->Wait.id == the_period->Object.id ) {
        _Thread_Unblock( the_thread );

        _Rate_monotonic_Initiate_statistics( the_period );
   470f8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   470fa:	4eb9 0004 69ac 	jsr 469ac <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   47100:	256a 004c 001c 	movel %a2@(76),%a2@(28)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   47106:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4710a:	4879 0005 b77c 	pea 5b77c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   47110:	4eb9 0004 aae4 	jsr 4aae4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   47116:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   4711c:	2039 0005 b6a0 	movel 5b6a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47122:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47124:	23c0 0005 b6a0 	movel %d0,5b6a0 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   4712a:	60ac           	bras 470d8 <_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 ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
   4712c:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   47130:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED

        _Rate_monotonic_Initiate_statistics( the_period );
   47134:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47136:	4eb9 0004 69ac 	jsr 469ac <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4713c:	256a 004c 001c 	movel %a2@(76),%a2@(28)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   47142:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   47146:	4879 0005 b77c 	pea 5b77c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   4714c:	4eb9 0004 aae4 	jsr 4aae4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   47152:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47158:	2039 0005 b6a0 	movel 5b6a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4715e:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47160:	23c0 0005 b6a0 	movel %d0,5b6a0 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   47166:	6000 ff70      	braw 470d8 <_Rate_monotonic_Timeout+0x54>         	<== NOT EXECUTED
	...

00046a2e <_Rate_monotonic_Update_statistics>:

void _Rate_monotonic_Update_statistics(
  Rate_monotonic_Control    *the_period
)
{
   46a2e:	4e56 ffb8      	linkw %fp,#-72                                    	<== NOT EXECUTED
   46a32:	48d7 3c3c      	moveml %d2-%d5/%a2-%a5,%sp@                       	<== NOT EXECUTED
   46a36:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
    struct timespec  uptime;

    /*
     * Obtain the current time since boot
     */
    _TOD_Get_uptime( &uptime );
   46a3a:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   46a3c:	0683 ffff ffe8 	addil #-24,%d3                                    	<== NOT EXECUTED
   46a42:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46a44:	4eb9 0004 8518 	jsr 48518 <_TOD_Get_uptime>                       	<== NOT EXECUTED

  /*
   *  Update the counts.
   */
  stats = &the_period->Statistics;
  stats->count++;
   46a4a:	52aa 0054      	addql #1,%a2@(84)                                 	<== NOT EXECUTED

  if ( the_period->state == RATE_MONOTONIC_EXPIRED )
   46a4e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46a50:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   46a52:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   46a56:	6700 0130      	beqw 46b88 <_Rate_monotonic_Update_statistics+0x15a>	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46a5a:	2a0e           	movel %fp,%d5                                     	<== NOT EXECUTED
   46a5c:	0685 ffff fff0 	addil #-16,%d5                                    	<== NOT EXECUTED
   46a62:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   46a64:	47f9 0004 a7fc 	lea 4a7fc <_Timespec_Subtract>,%a3                	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46a6a:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46a6c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46a6e:	0682 ffff ffe0 	addil #-32,%d2                                    	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46a74:	486a 0044      	pea %a2@(68)                                      	<== NOT EXECUTED
   46a78:	4e93           	jsr %a3@                                          	<== 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;
   46a7a:	2079 0005 b75e 	moveal 5b75e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46a80:	2d68 0088 ffdc 	movel %a0@(136),%fp@(-36)                         	<== NOT EXECUTED
   46a86:	2028 0084      	movel %a0@(132),%d0                               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46a8a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46a8c:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   46a8e:	0684 ffff ffd8 	addil #-40,%d4                                    	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46a94:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46a96:	4bf9 0004 a6b8 	lea 4a6b8 <_Timespec_Add_to>,%a5                  	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46a9c:	4879 0005 b766 	pea 5b766 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46aa2:	260a           	movel %a2,%d3                                     	<== NOT EXECUTED
   46aa4:	0683 0000 003c 	addil #60,%d3                                     	<== 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;
   46aaa:	2d40 ffd8      	movel %d0,%fp@(-40)                               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46aae:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46ab0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46ab2:	49f9 0004 a7c8 	lea 4a7c8 <_Timespec_Less_than>,%a4               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46ab8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46aba:	4e95           	jsr %a5@                                          	<== NOT EXECUTED

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46abc:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   46ac2:	2e83           	movel %d3,%sp@                                    	<== NOT EXECUTED
   46ac4:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46ac6:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   46ac8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46aca:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46acc:	670a           	beqs 46ad8 <_Rate_monotonic_Update_statistics+0xaa>	<== NOT EXECUTED
      stats->min_wall_time = since_last_period;

    if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) )
      stats->max_wall_time = since_last_period;
  #endif
}
   46ace:	4cee 3c3c ffb8 	moveml %fp@(-72),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   46ad4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46ad6:	4e75           	rts                                               	<== NOT EXECUTED
      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
        return;

       /* executed = current cpu usage - value at start of period */
      _Timespec_Subtract(
   46ad8:	0682 0000 0018 	addil #24,%d2                                     	<== NOT EXECUTED
   46ade:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46ae0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46ae2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46ae4:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
  /*
   *  Update CPU time
   */

  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
    _Timespec_Add_to( &stats->total_cpu_time, &executed );
   46ae6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46ae8:	486a 006c      	pea %a2@(108)                                     	<== NOT EXECUTED
   46aec:	4e95           	jsr %a5@                                          	<== NOT EXECUTED

    if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) )
   46aee:	486a 005c      	pea %a2@(92)                                      	<== NOT EXECUTED
   46af2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46af4:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   46af6:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   46afc:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46afe:	6710           	beqs 46b10 <_Rate_monotonic_Update_statistics+0xe2>	<== NOT EXECUTED
      stats->min_cpu_time = executed;
   46b00:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   46b04:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   46b08:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
   46b0c:	2541 0060      	movel %d1,%a2@(96)                                	<== NOT EXECUTED

    if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) )
   46b10:	486a 0064      	pea %a2@(100)                                     	<== NOT EXECUTED
   46b14:	47f9 0004 a794 	lea 4a794 <_Timespec_Greater_than>,%a3            	<== NOT EXECUTED
   46b1a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46b1c:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   46b1e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46b20:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46b22:	6710           	beqs 46b34 <_Rate_monotonic_Update_statistics+0x106>	<== NOT EXECUTED
      stats->max_cpu_time = executed;
   46b24:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   46b28:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   46b2c:	2540 0064      	movel %d0,%a2@(100)                               	<== NOT EXECUTED
   46b30:	2541 0068      	movel %d1,%a2@(104)                               	<== 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 );
   46b34:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   46b36:	486a 0084      	pea %a2@(132)                                     	<== NOT EXECUTED
   46b3a:	4e95           	jsr %a5@                                          	<== NOT EXECUTED

    if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) )
   46b3c:	486a 0074      	pea %a2@(116)                                     	<== NOT EXECUTED
   46b40:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   46b42:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   46b44:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   46b4a:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46b4c:	6710           	beqs 46b5e <_Rate_monotonic_Update_statistics+0x130>	<== NOT EXECUTED
      stats->min_wall_time = since_last_period;
   46b4e:	202e fff0      	movel %fp@(-16),%d0                               	<== NOT EXECUTED
   46b52:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED
   46b56:	2540 0074      	movel %d0,%a2@(116)                               	<== NOT EXECUTED
   46b5a:	2541 0078      	movel %d1,%a2@(120)                               	<== NOT EXECUTED

    if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) )
   46b5e:	486a 007c      	pea %a2@(124)                                     	<== NOT EXECUTED
   46b62:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   46b64:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   46b66:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46b68:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46b6a:	6700 ff62      	beqw 46ace <_Rate_monotonic_Update_statistics+0xa0>	<== NOT EXECUTED
      stats->max_wall_time = since_last_period;
   46b6e:	202e fff0      	movel %fp@(-16),%d0                               	<== NOT EXECUTED
   46b72:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED
   46b76:	2540 007c      	movel %d0,%a2@(124)                               	<== NOT EXECUTED
   46b7a:	2541 0080      	movel %d1,%a2@(128)                               	<== NOT EXECUTED
  #endif
}
   46b7e:	4cee 3c3c ffb8 	moveml %fp@(-72),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   46b84:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46b86:	4e75           	rts                                               	<== NOT EXECUTED
   */
  stats = &the_period->Statistics;
  stats->count++;

  if ( the_period->state == RATE_MONOTONIC_EXPIRED )
    stats->missed_count++;
   46b88:	52aa 0058      	addql #1,%a2@(88)                                 	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46b8c:	2a0e           	movel %fp,%d5                                     	<== NOT EXECUTED
   46b8e:	0685 ffff fff0 	addil #-16,%d5                                    	<== NOT EXECUTED
   46b94:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   46b96:	47f9 0004 a7fc 	lea 4a7fc <_Timespec_Subtract>,%a3                	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46b9c:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46b9e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46ba0:	0682 ffff ffe0 	addil #-32,%d2                                    	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   46ba6:	486a 0044      	pea %a2@(68)                                      	<== NOT EXECUTED
   46baa:	4e93           	jsr %a3@                                          	<== 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;
   46bac:	2079 0005 b75e 	moveal 5b75e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46bb2:	2d68 0088 ffdc 	movel %a0@(136),%fp@(-36)                         	<== NOT EXECUTED
   46bb8:	2028 0084      	movel %a0@(132),%d0                               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46bbc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46bbe:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   46bc0:	0684 ffff ffd8 	addil #-40,%d4                                    	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46bc6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46bc8:	4bf9 0004 a6b8 	lea 4a6b8 <_Timespec_Add_to>,%a5                  	<== NOT EXECUTED

      /* Grab CPU usage when the thread got switched in */
      used = _Thread_Executing->cpu_time_used;

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46bce:	4879 0005 b766 	pea 5b766 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46bd4:	260a           	movel %a2,%d3                                     	<== NOT EXECUTED
   46bd6:	0683 0000 003c 	addil #60,%d3                                     	<== 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;
   46bdc:	2d40 ffd8      	movel %d0,%fp@(-40)                               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46be0:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46be2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46be4:	49f9 0004 a7c8 	lea 4a7c8 <_Timespec_Less_than>,%a4               	<== NOT EXECUTED

      /* How much time time since last context switch */
      _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   46bea:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46bec:	4e95           	jsr %a5@                                          	<== NOT EXECUTED

      /* partial period, cpu usage info reset while executing.  Throw away */
      if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period))
   46bee:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   46bf4:	2e83           	movel %d3,%sp@                                    	<== NOT EXECUTED
   46bf6:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46bf8:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   46bfa:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46bfc:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46bfe:	6600 fece      	bnew 46ace <_Rate_monotonic_Update_statistics+0xa0>	<== NOT EXECUTED
   46c02:	6000 fed4      	braw 46ad8 <_Rate_monotonic_Update_statistics+0xaa>	<== NOT EXECUTED

0004ae24 <_Region_Manager_initialization>:
 */

void _Region_Manager_initialization(
  uint32_t   maximum_regions
)
{
   4ae24:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ae28:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ae2c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ae2e:	4878 00c0      	pea c0 <FP_REGS_SAVED+0x80>                       	<== NOT EXECUTED
   4ae32:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ae36:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4ae3a:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ae3e:	4879 0005 8b02 	pea 58b02 <_Region_Information>                   	<== NOT EXECUTED
   4ae44:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4ae4a:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_REGION,
    0  /* XXX _Region_MP_Process_packet */
  );
#endif

}
   4ae50:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ae52:	4e75           	rts

000597a4 <_Region_Process_queue>:
   597a4:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
 */

void _Region_Process_queue(
  Region_Control *the_region
)
{
   597aa:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   597ae:	48d7 3c1c      	moveml %d2-%d4/%a2-%a5,%sp@                       	<== NOT EXECUTED
   597b2:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   597b4:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   597ba:	266e 0008      	moveal %fp@(8),%a3                                	<== 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();
   597be:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== 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 );
   597c4:	240b           	movel %a3,%d2                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
  Region_Control *the_region,
  uint32_t        size
)
{
   return _Heap_Allocate( &the_region->Memory, size );
   597c6:	260b           	movel %a3,%d3                                     	<== NOT EXECUTED
   597c8:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   597ce:	49f9 0005 a0b4 	lea 5a0b4 <_Thread_queue_First>,%a4               	<== NOT EXECUTED
   597d4:	0683 0000 0068 	addil #104,%d3                                    	<== NOT EXECUTED
   597da:	4bf9 0005 4bf4 	lea 54bf4 <_Heap_Allocate>,%a5                    	<== 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();
   597e0:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   597e6:	588f           	addql #4,%sp                                      	<== 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 );
   597e8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   597ea:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
    if ( the_segment == NULL )
      break;

    *(void **)the_thread->Wait.return_argument = the_segment;
    the_region->number_of_used_blocks += 1;
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );
   597ec:	283c 0005 9f8c 	movel #368524,%d4                                 	<== 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 );
   597f2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    if ( the_thread == NULL )
   597f4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   597f6:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   597f8:	6732           	beqs 5982c <_Region_Process_queue+0x88>           	<== NOT EXECUTED
   597fa:	2f2a 0024      	movel %a2@(36),%sp@-                              	<== NOT EXECUTED
   597fe:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   59800:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
    the_segment = (void **) _Region_Allocate_segment(
      the_region,
      the_thread->Wait.count
    );

    if ( the_segment == NULL )
   59802:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   59804:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   59806:	6724           	beqs 5982c <_Region_Process_queue+0x88>           	<== NOT EXECUTED
      break;

    *(void **)the_thread->Wait.return_argument = the_segment;
   59808:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
    the_region->number_of_used_blocks += 1;
   5980c:	52ab 0064      	addql #1,%a3@(100)                                	<== NOT EXECUTED
    );

    if ( the_segment == NULL )
      break;

    *(void **)the_thread->Wait.return_argument = the_segment;
   59810:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
    the_region->number_of_used_blocks += 1;
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );
   59812:	2044           	moveal %d4,%a0                                    	<== NOT EXECUTED
   59814:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   59816:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   59818:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
   5981a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5981c:	42aa 0034      	clrl %a2@(52)                                     	<== 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 );
   59820:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   59822:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

    if ( the_thread == NULL )
   59824:	588f           	addql #4,%sp                                      	<== 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 );
   59826:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    if ( the_thread == NULL )
   59828:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5982a:	66ce           	bnes 597fa <_Region_Process_queue+0x56>           	<== NOT EXECUTED
    the_region->number_of_used_blocks += 1;
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
  }
  _Thread_Enable_dispatch();
}
   5982c:	4cee 3c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a5                  	<== NOT EXECUTED
   59832:	4e5e           	unlk %fp                                          	<== 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();
   59834:	4ef9 0005 62a4 	jmp 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
	...

0004ae90 <_Semaphore_Manager_initialization>:
 */

void _Semaphore_Manager_initialization(
  uint32_t   maximum_semaphores
)
{
   4ae90:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ae94:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ae98:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ae9a:	4878 0076      	pea 76 <FP_REGS_SAVED+0x36>                       	<== NOT EXECUTED
   4ae9e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4aea2:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED
   4aea6:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4aeaa:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   4aeb0:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
   4aeb6:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_SEMAPHORE,
    _Semaphore_MP_Process_packet
  );
#endif

}
   4aebc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aebe:	4e75           	rts

00045da4 <_Semaphore_Translate_core_mutex_return_code>:
};

rtems_status_code _Semaphore_Translate_core_mutex_return_code (
  uint32_t   status
)
{
   45da4:	4e56 0000      	linkw %fp,#0                                      	<== 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];
}
   45da8:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
};

rtems_status_code _Semaphore_Translate_core_mutex_return_code (
  uint32_t   status
)
{
   45dac:	41f9 0005 5bda 	lea 55bda <_Semaphore_Translate_core_mutex_return_code_>,%a0	<== 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];
}
   45db2:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   45db6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45db8:	4e75           	rts

00045dba <_Semaphore_Translate_core_semaphore_return_code>:
};

rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
  uint32_t   status
)
{
   45dba:	4e56 0000      	linkw %fp,#0                                      	<== 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];
}
   45dbe:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
};

rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
  uint32_t   status
)
{
   45dc2:	41f9 0005 5bf6 	lea 55bf6 <_Semaphore_Translate_core_semaphore_return_code_>,%a0	<== 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];
}
   45dc8:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   45dcc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45dce:	4e75           	rts

0004aec0 <_Signal_Manager_initialization>:
 *
 *  Output parameters:  NONE
 */

void _Signal_Manager_initialization( void )
{
   4aec0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _MPCI_Register_packet_processor(
    MP_PACKET_SIGNAL,
    _Signal_MP_Process_packet
  );
#endif
}
   4aec4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aec6:	4e75           	rts

00046b34 <_TOD_Get>:
 */

void _TOD_Get(
  struct timespec *time
)
{
   46b34:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   46b38:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  /* _TOD_Now is a proper POSIX time */
  _ISR_Disable( level );
   46b3a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _TOD_Get(
  struct timespec *time
)
{
   46b40:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46b42:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level level;
  struct timespec offset;

  /* assume time checked by caller */

  offset.tv_sec = 0;
   46b46:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  offset.tv_nsec = 0;
   46b4a:	42ae fffc      	clrl %fp@(-4)                                     	<== NOT EXECUTED

  /* _TOD_Now is a proper POSIX time */
  _ISR_Disable( level );
   46b4e:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46b50:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46b52:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    *time = _TOD_Now;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   46b54:	2079 0005 88ea 	moveal 588ea <_Watchdog_Nanoseconds_since_tick_handler>,%a0	<== NOT EXECUTED
  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  /* _TOD_Now is a proper POSIX time */
  _ISR_Disable( level );
    *time = _TOD_Now;
   46b5a:	2039 0005 87e6 	movel 587e6 <_TOD_Now>,%d0                        	<== NOT EXECUTED
   46b60:	2239 0005 87ea 	movel 587ea <_TOD_Now+0x4>,%d1                    	<== NOT EXECUTED
   46b66:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   46b68:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   46b6c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46b6e:	6706           	beqs 46b76 <_TOD_Get+0x42>                        	<== NOT EXECUTED
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
   46b70:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   46b72:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  _ISR_Enable( level );
   46b76:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  _Timespec_Add_to( time, &offset );
   46b78:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   46b7c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46b7e:	4eb9 0004 8ba0 	jsr 48ba0 <_Timespec_Add_to>                      	<== NOT EXECUTED
}
   46b84:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   46b88:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
    *time = _TOD_Now;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
  _ISR_Enable( level );

  _Timespec_Add_to( time, &offset );
   46b8c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   46b8e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46b90:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b3a4 <_TOD_Get_uptime>:
 */

void _TOD_Get_uptime(
  struct timespec *uptime
)
{
   4b3a4:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   4b3a8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  /* assume uptime checked by caller */

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  _ISR_Disable( level );
   4b3aa:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _TOD_Get_uptime(
  struct timespec *uptime
)
{
   4b3b0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4b3b2:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level level;
  struct timespec offset;

  /* assume uptime checked by caller */

  offset.tv_sec = 0;
   4b3b6:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  offset.tv_nsec = 0;
   4b3ba:	42ae fffc      	clrl %fp@(-4)                                     	<== NOT EXECUTED

  _ISR_Disable( level );
   4b3be:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   4b3c0:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4b3c2:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    *uptime = _TOD_Uptime;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   4b3c4:	2079 0005 88ea 	moveal 588ea <_Watchdog_Nanoseconds_since_tick_handler>,%a0	<== NOT EXECUTED

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  _ISR_Disable( level );
    *uptime = _TOD_Uptime;
   4b3ca:	2039 0005 87d2 	movel 587d2 <_TOD_Uptime>,%d0                     	<== NOT EXECUTED
   4b3d0:	2239 0005 87d6 	movel 587d6 <_TOD_Uptime+0x4>,%d1                 	<== NOT EXECUTED
   4b3d6:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   4b3d8:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   4b3dc:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4b3de:	6706           	beqs 4b3e6 <_TOD_Get_uptime+0x42>                 	<== NOT EXECUTED
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
   4b3e0:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4b3e2:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  _ISR_Enable( level );
   4b3e6:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  _Timespec_Add_to( uptime, &offset );
   4b3e8:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   4b3ec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b3ee:	4eb9 0004 8ba0 	jsr 48ba0 <_Timespec_Add_to>                      	<== NOT EXECUTED
}
   4b3f4:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   4b3f8:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
    *uptime = _TOD_Uptime;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
  _ISR_Enable( level );

  _Timespec_Add_to( uptime, &offset );
   4b3fc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   4b3fe:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b400:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046b94 <_TOD_Handler_initialization>:
 */

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
   46b94:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  /* Uptime (timespec) */
  _TOD_Uptime.tv_sec  = 0;
  _TOD_Uptime.tv_nsec = 0;

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
   46b98:	4200           	clrb %d0                                          	<== NOT EXECUTED

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;
   46b9a:	41ee 0008      	lea %fp@(8),%a0                                   	<== NOT EXECUTED
  /* Uptime (timespec) */
  _TOD_Uptime.tv_sec  = 0;
  _TOD_Uptime.tv_nsec = 0;

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
   46b9e:	13c0 0005 8768 	moveb %d0,58768 <_TOD_Is_set>                     	<== NOT EXECUTED

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;
   46ba4:	23d0 0005 88e2 	movel %a0@,588e2 <_TOD_Microseconds_per_tick>     	<== NOT EXECUTED
  _TOD_Uptime.tv_nsec = 0;

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
  _TOD_Activate();
}
   46baa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;

  /* POSIX format TOD (timespec) */
  _TOD_Now.tv_sec  = TOD_SECONDS_1970_THROUGH_1988;
   46bac:	203c 21da e500 	movel #567993600,%d0                              	<== NOT EXECUTED
  _TOD_Now.tv_nsec = 0;
   46bb2:	42b9 0005 87ea 	clrl 587ea <_TOD_Now+0x4>                         	<== NOT EXECUTED
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;

  /* POSIX format TOD (timespec) */
  _TOD_Now.tv_sec  = TOD_SECONDS_1970_THROUGH_1988;
   46bb8:	23c0 0005 87e6 	movel %d0,587e6 <_TOD_Now>                        	<== NOT EXECUTED
  _TOD_Now.tv_nsec = 0;

  /* Uptime (timespec) */
  _TOD_Uptime.tv_sec  = 0;
   46bbe:	42b9 0005 87d2 	clrl 587d2 <_TOD_Uptime>                          	<== NOT EXECUTED
  _TOD_Uptime.tv_nsec = 0;
   46bc4:	42b9 0005 87d6 	clrl 587d6 <_TOD_Uptime+0x4>                      	<== NOT EXECUTED

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
  _TOD_Activate();
}
   46bca:	4e75           	rts

00047f24 <_TOD_Set>:
   47f24:	2039 0006 2d7c 	movel 62d7c <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
 */

void _TOD_Set(
  const struct timespec *time
)
{
   47f2a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47f2e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47f30:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47f32:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   47f36:	23c0 0006 2d7c 	movel %d0,62d7c <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  _Thread_Disable_dispatch();
  _TOD_Deactivate();

  if ( time->tv_sec < _TOD_Seconds_since_epoch )
   47f3c:	2239 0006 2e0e 	movel 62e0e <_TOD_Now>,%d1                        	<== NOT EXECUTED
   47f42:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   47f44:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47f46:	6e3c           	bgts 47f84 <_TOD_Set+0x60>                        	<== NOT EXECUTED
  Watchdog_Adjust_directions direction,
  Watchdog_Interval          units
)
{

  _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
   47f48:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   47f4a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47f4c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47f4e:	4879 0006 2e4c 	pea 62e4c <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   47f54:	4eb9 0004 a670 	jsr 4a670 <_Watchdog_Adjust>                      	<== NOT EXECUTED
  else
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
   47f5a:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   47f5c:	588a           	addql #4,%a2                                      	<== NOT EXECUTED
   47f5e:	23d2 0006 2e12 	movel %a2@,62e12 <_TOD_Now+0x4>                   	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
}
   47f64:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47f68:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47f6e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
  _TOD_Is_set              = TRUE;
   47f70:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   47f72:	13c1 0006 2d90 	moveb %d1,62d90 <_TOD_Is_set>                     	<== NOT EXECUTED
  else
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
   47f78:	23c0 0006 2e0e 	movel %d0,62e0e <_TOD_Now>                        	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
   47f7e:	4ef9 0004 9194 	jmp 49194 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   47f84:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   47f86:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   47f88:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   47f8c:	4879 0006 2e4c 	pea 62e4c <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   47f92:	4eb9 0004 a670 	jsr 4a670 <_Watchdog_Adjust>                      	<== NOT EXECUTED
  else
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
   47f98:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   47f9a:	588a           	addql #4,%a2                                      	<== NOT EXECUTED
   47f9c:	23d2 0006 2e12 	movel %a2@,62e12 <_TOD_Now+0x4>                   	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
}
   47fa2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47fa6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47fac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
  _TOD_Is_set              = TRUE;
   47fae:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   47fb0:	13c1 0006 2d90 	moveb %d1,62d90 <_TOD_Is_set>                     	<== NOT EXECUTED
  else
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
   47fb6:	23c0 0006 2e0e 	movel %d0,62e0e <_TOD_Now>                        	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
   47fbc:	4ef9 0004 9194 	jmp 49194 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
	...

00046bcc <_TOD_Tickle_ticks>:
 *
 *  Output parameters: NONE
 */

void _TOD_Tickle_ticks( void )
{
   46bcc:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   46bd0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46bd2:	2239 0005 88e2 	movel 588e2 <_TOD_Microseconds_per_tick>,%d1      	<== NOT EXECUTED
 *
 *  Output parameters: NONE
 */

void _TOD_Tickle_ticks( void )
{
   46bd8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46bda:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   46bdc:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   46bde:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   46be0:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
  tick.tv_sec  = 0;

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;
   46be2:	2079 0005 889c 	moveal 5889c <_Watchdog_Ticks_since_boot>,%a0     	<== NOT EXECUTED
{
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46be8:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   46bea:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
{
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46bec:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   46bee:	5182           	subql #8,%d2                                      	<== NOT EXECUTED
   46bf0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
  tick.tv_sec  = 0;

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;
   46bf2:	5288           	addql #1,%a0                                      	<== NOT EXECUTED
{
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46bf4:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   46bf6:	45f9 0004 8ba0 	lea 48ba0 <_Timespec_Add_to>,%a2                  	<== NOT EXECUTED
  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
  tick.tv_sec  = 0;

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;
   46bfc:	23c8 0005 889c 	movel %a0,5889c <_Watchdog_Ticks_since_boot>      	<== NOT EXECUTED

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   46c02:	4879 0005 87d2 	pea 587d2 <_TOD_Uptime>                           	<== NOT EXECUTED
{
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   46c08:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  tick.tv_sec  = 0;
   46c0c:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   46c10:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
  /* we do not care how much the uptime changed */

  /* Update the timespec format TOD */
  seconds = _Timespec_Add_to( &_TOD_Now, &tick );
   46c12:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46c14:	4879 0005 87e6 	pea 587e6 <_TOD_Now>                              	<== NOT EXECUTED
   46c1a:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
  while ( seconds ) {
   46c1c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  /* Update the timespec format uptime */
  (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 );
   46c22:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  while ( seconds ) {
   46c24:	6714           	beqs 46c3a <_TOD_Tickle_ticks+0x6e>               	<== NOT EXECUTED
   46c26:	45f9 0004 90c0 	lea 490c0 <_Watchdog_Tickle>,%a2                  	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{

  _Watchdog_Tickle( &_Watchdog_Seconds_chain );
   46c2c:	4879 0005 8824 	pea 58824 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   46c32:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
    _Watchdog_Tickle_seconds();
    seconds--;
   46c34:	5382           	subql #1,%d2                                      	<== 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 ) {
   46c36:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46c38:	66f2           	bnes 46c2c <_TOD_Tickle_ticks+0x60>               	<== NOT EXECUTED
    _Watchdog_Tickle_seconds();
    seconds--;
  }
}
   46c3a:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   46c3e:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   46c42:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c44:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046404 <_TOD_To_seconds>:
 */

uint32_t   _TOD_To_seconds(
  rtems_time_of_day *the_tod
)
{
   46404:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   46408:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
   4640c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  uint32_t   time;
  uint32_t   year_mod_4;

  time = the_tod->day - 1;
  year_mod_4 = the_tod->year & 3;
   46410:	2412           	movel %a2@,%d2                                    	<== NOT EXECUTED
)
{
  uint32_t   time;
  uint32_t   year_mod_4;

  time = the_tod->day - 1;
   46412:	226a 0008      	moveal %a2@(8),%a1                                	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;
   46416:	7803           	moveq #3,%d4                                      	<== NOT EXECUTED
)
{
  uint32_t   time;
  uint32_t   year_mod_4;

  time = the_tod->day - 1;
   46418:	5389           	subql #1,%a1                                      	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;
   4641a:	c882           	andl %d2,%d4                                      	<== NOT EXECUTED

  if ( year_mod_4 == 0 )
   4641c:	6700 008a      	beqw 464a8 <_TOD_To_seconds+0xa4>                 	<== NOT EXECUTED
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   46420:	202a 0004      	movel %a2@(4),%d0                                 	<== NOT EXECUTED
   46424:	41f9 0005 83be 	lea 583be <_TOD_Days_to_date>,%a0                 	<== NOT EXECUTED
   4642a:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4642c:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   46430:	0682 ffff f83c 	addil #-1988,%d2                                  	<== NOT EXECUTED
   46436:	e48a           	lsrl #2,%d2                                       	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   46438:	2a01           	movel %d1,%d5                                     	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   4643a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4643c:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4643e:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
   46440:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   46442:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   46444:	da89           	addl %a1,%d5                                      	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   46446:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46448:	262a 000c      	movel %a2@(12),%d3                                	<== NOT EXECUTED
  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   4644c:	43f9 0005 83f2 	lea 583f2 <_TOD_Days_since_last_leap_year>,%a1    	<== NOT EXECUTED
   46452:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46454:	3031 4a00      	movew %a1@(00000000,%d4:l:2),%d0                  	<== NOT EXECUTED
   46458:	d1c2           	addal %d2,%a0                                     	<== NOT EXECUTED
   4645a:	2242           	moveal %d2,%a1                                    	<== NOT EXECUTED
   4645c:	41f0 8c00      	lea %a0@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   46460:	41f1 8c00      	lea %a1@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46464:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   46466:	d088           	addl %a0,%d0                                      	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46468:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   4646a:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
   4646c:	d085           	addl %d5,%d0                                      	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   4646e:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46470:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   46472:	7609           	moveq #9,%d3                                      	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46474:	d2aa 0010      	addl %a2@(16),%d1                                 	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46478:	e7aa           	lsll %d3,%d2                                      	<== NOT EXECUTED
   4647a:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
   4647c:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   4647e:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
   46480:	206a 0014      	moveal %a2@(20),%a0                               	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46484:	e98b           	lsll #4,%d3                                       	<== NOT EXECUTED
   46486:	9682           	subl %d2,%d3                                      	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46488:	2801           	movel %d1,%d4                                     	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   4648a:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   4648c:	ed8c           	lsll #6,%d4                                       	<== NOT EXECUTED
   4648e:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   46490:	9881           	subl %d1,%d4                                      	<== NOT EXECUTED

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
   46492:	d1fc 21da e500 	addal #567993600,%a0                              	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46498:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   4649a:	d1c4           	addal %d4,%a0                                     	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   4649c:	9083           	subl %d3,%d0                                      	<== NOT EXECUTED
  time += the_tod->second;

  time += TOD_SECONDS_1970_THROUGH_1988;

  return( time );
}
   4649e:	4cd7 043c      	moveml %sp@,%d2-%d5/%a2                           	<== NOT EXECUTED
   464a2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   464a4:	d088           	addl %a0,%d0                                      	<== NOT EXECUTED
   464a6:	4e75           	rts                                               	<== NOT EXECUTED

  time = the_tod->day - 1;
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
   464a8:	202a 0004      	movel %a2@(4),%d0                                 	<== NOT EXECUTED
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   464ac:	41f9 0005 83be 	lea 583be <_TOD_Days_to_date>,%a0                 	<== NOT EXECUTED

  time = the_tod->day - 1;
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
   464b2:	0680 0000 000d 	addil #13,%d0                                     	<== NOT EXECUTED
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   464b8:	4281           	clrl %d1                                          	<== NOT EXECUTED
   464ba:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   464be:	0682 ffff f83c 	addil #-1988,%d2                                  	<== NOT EXECUTED
   464c4:	e48a           	lsrl #2,%d2                                       	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   464c6:	2a01           	movel %d1,%d5                                     	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   464c8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   464ca:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   464cc:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
   464ce:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   464d0:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;

  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   464d2:	da89           	addl %a1,%d5                                      	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   464d4:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   464d6:	262a 000c      	movel %a2@(12),%d3                                	<== NOT EXECUTED
  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   464da:	43f9 0005 83f2 	lea 583f2 <_TOD_Days_since_last_leap_year>,%a1    	<== NOT EXECUTED
   464e0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   464e2:	3031 4a00      	movew %a1@(00000000,%d4:l:2),%d0                  	<== NOT EXECUTED
   464e6:	d1c2           	addal %d2,%a0                                     	<== NOT EXECUTED
   464e8:	2242           	moveal %d2,%a1                                    	<== NOT EXECUTED
   464ea:	41f0 8c00      	lea %a0@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   464ee:	41f1 8c00      	lea %a1@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   464f2:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
  if ( year_mod_4 == 0 )
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   464f4:	d088           	addl %a0,%d0                                      	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   464f6:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   464f8:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
   464fa:	d085           	addl %d5,%d0                                      	<== NOT EXECUTED
  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   464fc:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   464fe:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   46500:	7609           	moveq #9,%d3                                      	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46502:	d2aa 0010      	addl %a2@(16),%d1                                 	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46506:	e7aa           	lsll %d3,%d2                                      	<== NOT EXECUTED
   46508:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
   4650a:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   4650c:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
   4650e:	206a 0014      	moveal %a2@(20),%a0                               	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46512:	e98b           	lsll #4,%d3                                       	<== NOT EXECUTED
   46514:	9682           	subl %d2,%d3                                      	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46516:	2801           	movel %d1,%d4                                     	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46518:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   4651a:	ed8c           	lsll #6,%d4                                       	<== NOT EXECUTED
   4651c:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   4651e:	9881           	subl %d1,%d4                                      	<== NOT EXECUTED

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
   46520:	d1fc 21da e500 	addal #567993600,%a0                              	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   46526:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   46528:	d1c4           	addal %d4,%a0                                     	<== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];

  time *= TOD_SECONDS_PER_DAY;
   4652a:	9083           	subl %d3,%d0                                      	<== NOT EXECUTED
  time += the_tod->second;

  time += TOD_SECONDS_1970_THROUGH_1988;

  return( time );
}
   4652c:	4cd7 043c      	moveml %sp@,%d2-%d5/%a2                           	<== NOT EXECUTED
   46530:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46532:	d088           	addl %a0,%d0                                      	<== NOT EXECUTED
   46534:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046538 <_TOD_Validate>:
 */

bool _TOD_Validate(
  rtems_time_of_day *the_tod
)
{
   46538:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4653c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   46540:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t   days_in_month;

  if ((!the_tod)                                  ||
   46542:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46544:	6768           	beqs 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   46546:	43f9 0006 2f0a 	lea 62f0a <_TOD_Microseconds_per_tick>,%a1        	<== NOT EXECUTED
   4654c:	203c 000f 4240 	movel #1000000,%d0                                	<== NOT EXECUTED
   46552:	4c51 0000      	remul %a1@,%d0,%d0                                	<== NOT EXECUTED
   46556:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   4655a:	6352           	blss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   4655c:	703b           	moveq #59,%d0                                     	<== NOT EXECUTED
   4655e:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   46562:	654a           	bcss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   46564:	b0a8 0010      	cmpl %a0@(16),%d0                                 	<== NOT EXECUTED
   46568:	6544           	bcss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   4656a:	7217           	moveq #23,%d1                                     	<== NOT EXECUTED
   4656c:	b2a8 000c      	cmpl %a0@(12),%d1                                 	<== NOT EXECUTED
   46570:	653c           	bcss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   46572:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
   46576:	6736           	beqs 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   46578:	740c           	moveq #12,%d2                                     	<== NOT EXECUTED
   4657a:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   4657c:	6530           	bcss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   4657e:	2210           	movel %a0@,%d1                                    	<== NOT EXECUTED
   46580:	0c81 0000 07c3 	cmpil #1987,%d1                                   	<== NOT EXECUTED
   46586:	6326           	blss 465ae <_TOD_Validate+0x76>                   	<== NOT EXECUTED
   46588:	2268 0008      	moveal %a0@(8),%a1                                	<== NOT EXECUTED
   4658c:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4658e:	671e           	beqs 465ae <_TOD_Validate+0x76>                   	<== 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 )
   46590:	143c 0003      	moveb #3,%d2                                      	<== NOT EXECUTED
   46594:	c282           	andl %d2,%d1                                      	<== NOT EXECUTED
   46596:	661e           	bnes 465b6 <_TOD_Validate+0x7e>                   	<== NOT EXECUTED
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
   46598:	41f9 0005 83fa 	lea 583fa <_TOD_Days_per_month>,%a0               	<== NOT EXECUTED
   4659e:	2030 0c34      	movel %a0@(00000034,%d0:l:4),%d0                  	<== NOT EXECUTED
  else
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
   465a2:	b3c0           	cmpal %d0,%a1                                     	<== NOT EXECUTED
   465a4:	53c0           	sls %d0                                           	<== NOT EXECUTED
   465a6:	4480           	negl %d0                                          	<== NOT EXECUTED

  if ( the_tod->day > days_in_month )
    return false;

  return true;
}
   465a8:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   465aa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465ac:	4e75           	rts                                               	<== NOT EXECUTED
   465ae:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   465b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
     return false;

  if ( (the_tod->year % 4) == 0 )
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
  else
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
   465b2:	4200           	clrb %d0                                          	<== NOT EXECUTED

  if ( the_tod->day > days_in_month )
    return false;

  return true;
}
   465b4:	4e75           	rts                                               	<== NOT EXECUTED
     return false;

  if ( (the_tod->year % 4) == 0 )
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
  else
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
   465b6:	41f9 0005 83fa 	lea 583fa <_TOD_Days_per_month>,%a0               	<== NOT EXECUTED
   465bc:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   465c0:	b3c0           	cmpal %d0,%a1                                     	<== NOT EXECUTED
   465c2:	53c0           	sls %d0                                           	<== NOT EXECUTED
   465c4:	4480           	negl %d0                                          	<== NOT EXECUTED
   465c6:	60e0           	bras 465a8 <_TOD_Validate+0x70>                   	<== NOT EXECUTED

00047794 <_Thread_Change_priority>:
void _Thread_Change_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority,
  bool              prepend_it
)
{
   47794:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   47798:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
   4779c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   477a0:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
*/

  /*
   * Save original state
   */
  original_state = the_thread->current_state;
   477a4:	262a 0010      	movel %a2@(16),%d3                                	<== 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 );
   477a8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
void _Thread_Change_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority,
  bool              prepend_it
)
{
   477aa:	1a2e 0013      	moveb %fp@(19),%d5                                	<== 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 );
   477ae:	4eb9 0004 879c 	jsr 4879c <_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 )
   477b4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   477b6:	b4aa 0014      	cmpl %a2@(20),%d2                                 	<== NOT EXECUTED
   477ba:	670c           	beqs 477c8 <_Thread_Change_priority+0x34>         	<== NOT EXECUTED
    _Thread_Set_priority( the_thread, new_priority );
   477bc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   477be:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   477c0:	4eb9 0004 8618 	jsr 48618 <_Thread_Set_priority>                  	<== NOT EXECUTED
   477c6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

  _ISR_Disable( level );
   477c8:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   477ce:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   477d0:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   477d2:	46c0           	movew %d0,%sr                                     	<== 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;
   477d4:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
  if ( state != STATES_TRANSIENT ) {
   477d8:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   477da:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   477dc:	6738           	beqs 47816 <_Thread_Change_priority+0x82>         	<== NOT EXECUTED
    /* Only clear the transient state if it wasn't set already */
    if ( ! _States_Is_transient( original_state ) )
   477de:	44c3           	movew %d3,%ccr                                    	<== NOT EXECUTED
   477e0:	6708           	beqs 477ea <_Thread_Change_priority+0x56>         	<== NOT EXECUTED
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
   477e2:	72fb           	moveq #-5,%d1                                     	<== NOT EXECUTED
   477e4:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
   477e6:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED
    _ISR_Enable( level );
   477ea:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( state ) ) {
   477ec:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   477f2:	660a           	bnes 477fe <_Thread_Change_priority+0x6a>         	<== NOT EXECUTED

  if ( !_Thread_Is_executing_also_the_heir() &&
       _Thread_Executing->is_preemptible )
    _Context_Switch_necessary = TRUE;
  _ISR_Enable( level );
}
   477f4:	4cee 043c ffec 	moveml %fp@(-20),%d2-%d5/%a2                      	<== NOT EXECUTED
   477fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   477fc:	4e75           	rts                                               	<== 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 );
   477fe:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   47802:	2d6a 0044 0008 	movel %a2@(68),%fp@(8)                            	<== NOT EXECUTED

  if ( !_Thread_Is_executing_also_the_heir() &&
       _Thread_Executing->is_preemptible )
    _Context_Switch_necessary = TRUE;
  _ISR_Enable( level );
}
   47808:	4cee 043c ffec 	moveml %fp@(-20),%d2-%d5/%a2                      	<== NOT EXECUTED
   4780e:	4e5e           	unlk %fp                                          	<== 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 );
   47810:	4ef9 0004 8564 	jmp 48564 <_Thread_queue_Requeue>                 	<== NOT EXECUTED
    }
    return;
  }

  /* Only clear the transient state if it wasn't set already */
  if ( ! _States_Is_transient( original_state ) ) {
   47816:	44c3           	movew %d3,%ccr                                    	<== NOT EXECUTED
   47818:	673c           	beqs 47856 <_Thread_Change_priority+0xc2>         	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor |= the_priority_map->ready_minor;
   4781a:	206a 0090      	moveal %a2@(144),%a0                              	<== NOT EXECUTED
   4781e:	322a 0096      	movew %a2@(150),%d1                               	<== NOT EXECUTED
   47822:	3010           	movew %a0@,%d0                                    	<== NOT EXECUTED
   47824:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47826:	3080           	movew %d0,%a0@                                    	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   47828:	3239 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   4782e:	302a 0094      	movew %a2@(148),%d0                               	<== NOT EXECUTED
   47832:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   47834:	33c1 0005 8808 	movew %d1,58808 <_Priority_Major_bit_map>         	<== 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 );
   4783a:	42aa 0010      	clrl %a2@(16)                                     	<== NOT EXECUTED

    _Priority_Add_to_bit_map( &the_thread->Priority_map );
    if ( prepend_it )
   4783e:	4a05           	tstb %d5                                          	<== NOT EXECUTED
   47840:	6700 0084      	beqw 478c6 <_Thread_Change_priority+0x132>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
   47844:	206a 008c      	moveal %a2@(140),%a0                              	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   47848:	2250           	moveal %a0@,%a1                                   	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   4784a:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
   4784e:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
  the_node->next        = before_node;
  before_node->previous = the_node;
   47850:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
   47854:	2489           	movel %a1,%a2@                                    	<== 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 );
   47856:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4785c:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   4785e:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   47860:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
  Priority_Bit_map_control minor;
  Priority_Bit_map_control major;

  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
   47862:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   47868:	4840           	swap %d0                                          	<== NOT EXECUTED
   4786a:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   4786c:	41f9 0005 8878 	lea 58878 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   47872:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   47878:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   4787c:	4841           	swap %d1                                          	<== NOT EXECUTED
   4787e:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   47880:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   47886:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   47888:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4788a:	2079 0005 8700 	moveal 58700 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   47890:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   47892:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   47894:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   47896:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   47898:	2230 2800      	movel %a0@(00000000,%d2:l),%d1                    	<== NOT EXECUTED
 *  is also the heir thread, and FALSE otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
  return ( _Thread_Executing == _Thread_Heir );
   4789c:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   478a2:	23c1 0005 87e2 	movel %d1,587e2 <_Thread_Heir>                    	<== 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() &&
   478a8:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   478aa:	670e           	beqs 478ba <_Thread_Change_priority+0x126>        	<== NOT EXECUTED
   478ac:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   478b0:	6708           	beqs 478ba <_Thread_Change_priority+0x126>        	<== NOT EXECUTED
       _Thread_Executing->is_preemptible )
    _Context_Switch_necessary = TRUE;
   478b2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   478b4:	13c1 0005 8822 	moveb %d1,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
  _ISR_Enable( level );
   478ba:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   478bc:	4cee 043c ffec 	moveml %fp@(-20),%d2-%d5/%a2                      	<== NOT EXECUTED
   478c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   478c4:	4e75           	rts                                               	<== NOT EXECUTED

    _Priority_Add_to_bit_map( &the_thread->Priority_map );
    if ( prepend_it )
      _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
    else
      _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
   478c6:	206a 008c      	moveal %a2@(140),%a0                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   478ca:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   478cc:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   478ce:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   478d0:	2268 0008      	moveal %a0@(8),%a1                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   478d4:	214a 0008      	movel %a2,%a0@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   478d8:	2549 0004      	movel %a1,%a2@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   478dc:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
   478de:	6000 ff76      	braw 47856 <_Thread_Change_priority+0xc2>         	<== NOT EXECUTED
	...

000478e4 <_Thread_Clear_state>:

void _Thread_Clear_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   478e4:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   478e8:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   478ec:	283c 0000 0700 	movel #1792,%d4                                   	<== NOT EXECUTED

void _Thread_Clear_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   478f2:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   478f6:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   478fa:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   478fc:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   478fe:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   47900:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    current_state = the_thread->current_state;
   47902:	222b 0010      	movel %a3@(16),%d1                                	<== NOT EXECUTED

    if ( current_state & state ) {
   47906:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   47908:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4790a:	677a           	beqs 47986 <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
  States_Control states_to_clear,
  States_Control current_state
)
{
   return (current_state & ~states_to_clear);
   4790c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4790e:	4680           	notl %d0                                          	<== NOT EXECUTED
   47910:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
      current_state =
   47912:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
      the_thread->current_state = _States_Clear( state, current_state );

      if ( _States_Is_ready( current_state ) ) {
   47916:	666e           	bnes 47986 <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED

        _Priority_Add_to_bit_map( &the_thread->Priority_map );

        _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
   47918:	206b 008c      	moveal %a3@(140),%a0                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4791c:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor |= the_priority_map->ready_minor;
   4791e:	226b 0090      	moveal %a3@(144),%a1                              	<== NOT EXECUTED
   47922:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   47924:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   47926:	2468 0008      	moveal %a0@(8),%a2                                	<== NOT EXECUTED
   4792a:	322b 0096      	movew %a3@(150),%d1                               	<== NOT EXECUTED
   4792e:	3011           	movew %a1@,%d0                                    	<== NOT EXECUTED
   47930:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47932:	3280           	movew %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   47934:	214b 0008      	movel %a3,%a0@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   47938:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4793e:	322b 0094      	movew %a3@(148),%d1                               	<== NOT EXECUTED
   47942:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47944:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4794a:	274a 0004      	movel %a2,%a3@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   4794e:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED

        _ISR_Flash( level );
   47950:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   47952:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   47954:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   47956:	46c0           	movew %d0,%sr                                     	<== 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 ) {
   47958:	2079 0005 87e2 	moveal 587e2 <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   4795e:	202b 0014      	movel %a3@(20),%d0                                	<== NOT EXECUTED
   47962:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   47966:	641e           	bccs 47986 <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED
          _Thread_Heir = the_thread;
          if ( _Thread_Executing->is_preemptible ||
   47968:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
         *  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 ) {
          _Thread_Heir = the_thread;
   4796e:	23cb 0005 87e2 	movel %a3,587e2 <_Thread_Heir>                    	<== NOT EXECUTED
          if ( _Thread_Executing->is_preemptible ||
   47974:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   47978:	6604           	bnes 4797e <_Thread_Clear_state+0x9a>             	<== NOT EXECUTED
   4797a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4797c:	6608           	bnes 47986 <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED
               the_thread->current_priority == 0 )
            _Context_Switch_necessary = TRUE;
   4797e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47980:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
        }
      }
  }
  _ISR_Enable( level );
   47986:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   47988:	4cd7 0c1c      	moveml %sp@,%d2-%d4/%a2-%a3                       	<== NOT EXECUTED
   4798c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4798e:	4e75           	rts

00047990 <_Thread_Close>:

void _Thread_Close(
  Objects_Information  *information,
  Thread_Control       *the_thread
)
{
   47990:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47994:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47996:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   4799a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4799c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   479a0:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   479a4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   479a6:	302b 000a      	movew %a3@(10),%d0                                	<== NOT EXECUTED
   479aa:	42b0 0c00      	clrl %a0@(00000000,%d0:l:4)                       	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   479ae:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   479b4:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   479b6:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   *  disappear and set a transient state on it.  So we temporarily
   *  unnest dispatching.
   */
  _Thread_Unnest_dispatch();

  _User_extensions_Thread_delete( the_thread );
   479bc:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   479be:	4eb9 0004 8e08 	jsr 48e08 <_User_extensions_Thread_delete>        	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   479c4:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   479ca:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   479cc:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== 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 );
   479d2:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   479d4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   479d6:	4eb9 0004 6fa8 	jsr 46fa8 <_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 );
   479dc:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   479e0:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   479e2:	4eb9 0004 8680 	jsr 48680 <_Thread_Set_state>                     	<== NOT EXECUTED

  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
   479e8:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   479ea:	4eb9 0004 8474 	jsr 48474 <_Thread_queue_Extract_with_proxy>      	<== NOT EXECUTED
   479f0:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   479f6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   479f8:	6608           	bnes 47a02 <_Thread_Close+0x72>                   	<== NOT EXECUTED
    if ( _Watchdog_Is_active( &the_thread->Timer ) )
   479fa:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   479fc:	b0ab 0050      	cmpl %a3@(80),%d0                                 	<== NOT EXECUTED
   47a00:	6756           	beqs 47a58 <_Thread_Close+0xc8>                   	<== NOT EXECUTED
  /*
   *  The thread might have been FP.  So deal with that.
   */
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
  if ( _Thread_Is_allocated_fp( the_thread ) )
   47a02:	b7f9 0005 87da 	cmpal 587da <_Thread_Allocated_fp>,%a3            	<== NOT EXECUTED
   47a08:	6746           	beqs 47a50 <_Thread_Close+0xc0>                   	<== NOT EXECUTED
    _Thread_Deallocate_fp();
#endif
  the_thread->fp_context = NULL;

  if ( the_thread->Start.fp_context )
   47a0a:	202b 00c8      	movel %a3@(200),%d0                               	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
  if ( _Thread_Is_allocated_fp( the_thread ) )
    _Thread_Deallocate_fp();
#endif
  the_thread->fp_context = NULL;
   47a0e:	42ab 0104      	clrl %a3@(260)                                    	<== NOT EXECUTED

  if ( the_thread->Start.fp_context )
   47a12:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47a14:	670a           	beqs 47a20 <_Thread_Close+0x90>                   	<== NOT EXECUTED
    (void) _Workspace_Free( the_thread->Start.fp_context );
   47a16:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47a18:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   47a1e:	588f           	addql #4,%sp                                      	<== 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 );
   47a20:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47a22:	4eb9 0004 888c 	jsr 4888c <_Thread_Stack_Free>                    	<== NOT EXECUTED
  the_thread->Start.stack = NULL;

  if ( the_thread->extensions )
   47a28:	202b 0118      	movel %a3@(280),%d0                               	<== 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 );
  the_thread->Start.stack = NULL;
   47a2c:	42ab 00cc      	clrl %a3@(204)                                    	<== NOT EXECUTED

  if ( the_thread->extensions )
   47a30:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47a32:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47a34:	670a           	beqs 47a40 <_Thread_Close+0xb0>                   	<== NOT EXECUTED
    (void) _Workspace_Free( the_thread->extensions );
   47a36:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47a38:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   47a3e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  the_thread->extensions = NULL;
   47a40:	42ab 0118      	clrl %a3@(280)                                    	<== NOT EXECUTED
}
   47a44:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   47a48:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   47a4c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47a4e:	4e75           	rts                                               	<== NOT EXECUTED
 */

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE void _Thread_Deallocate_fp( void )
{
  _Thread_Allocated_fp = NULL;
   47a50:	42b9 0005 87da 	clrl 587da <_Thread_Allocated_fp>                 	<== NOT EXECUTED
   47a56:	60b2           	bras 47a0a <_Thread_Close+0x7a>                   	<== NOT EXECUTED
   */
  _Thread_Set_state( the_thread, STATES_DORMANT );

  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
    if ( _Watchdog_Is_active( &the_thread->Timer ) )
      (void) _Watchdog_Remove( &the_thread->Timer );
   47a58:	486b 0048      	pea %a3@(72)                                      	<== NOT EXECUTED
   47a5c:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   47a62:	588f           	addql #4,%sp                                      	<== 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 ) )
   47a64:	b7f9 0005 87da 	cmpal 587da <_Thread_Allocated_fp>,%a3            	<== NOT EXECUTED
   47a6a:	669e           	bnes 47a0a <_Thread_Close+0x7a>                   	<== NOT EXECUTED
   47a6c:	60e2           	bras 47a50 <_Thread_Close+0xc0>                   	<== NOT EXECUTED
	...

00047a70 <_Thread_Create_idle>:
 *
 *  _Thread_Create_idle
 */

void _Thread_Create_idle( void )
{
   47a70:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 *  This routine allocates an internal thread.
 */

RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void )
{
  return (Thread_Control *) _Objects_Allocate( &_Thread_Internal_information );
   47a74:	4879 0005 88a6 	pea 588a6 <_Thread_Internal_information>          	<== NOT EXECUTED
   47a7a:	4eb9 0004 6f0c 	jsr 46f0c <_Objects_Allocate>                     	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   47a80:	2239 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d1  	<== NOT EXECUTED
   47a86:	5281           	addql #1,%d1                                      	<== 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();
   47a88:	23c0 0005 88ee 	movel %d0,588ee <_Thread_Idle>                    	<== NOT EXECUTED
   47a8e:	23c1 0005 8754 	movel %d1,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   *  that when _Thread_Initialize unnests dispatch that we do not
   *  do anything stupid.
   */
  _Thread_Disable_dispatch();

  _Thread_Initialize(
   47a94:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47a9a:	2068 0018      	moveal %a0@(24),%a0                               	<== NOT EXECUTED
   47a9e:	4879 0005 5c6a 	pea 55c6a <_Status_Object_name_errors_to_status+0x14>	<== NOT EXECUTED
   47aa4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47aa6:	1039 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   47aac:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47aae:	2239 0005 6c3e 	movel 56c3e <rtems_minimum_stack_size>,%d1        	<== NOT EXECUTED
   47ab4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47ab6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47ab8:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   47abc:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47abe:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47ac0:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   47ac2:	6302           	blss 47ac6 <_Thread_Create_idle+0x56>             	<== NOT EXECUTED
   47ac4:	2208           	movel %a0,%d1                                     	<== NOT EXECUTED
   47ac6:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   47ac8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47aca:	2f39 0005 88ee 	movel 588ee <_Thread_Idle>,%sp@-                  	<== NOT EXECUTED
   47ad0:	4879 0005 88a6 	pea 588a6 <_Thread_Internal_information>          	<== NOT EXECUTED
   47ad6:	4eb9 0004 7d90 	jsr 47d90 <_Thread_Initialize>                    	<== NOT EXECUTED
   *             MUST be done before _Thread_Start is invoked.
   */
  _Thread_Heir      =
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   47adc:	dffc 0000 002c 	addal #44,%sp                                     	<== NOT EXECUTED
   47ae2:	4297           	clrl %sp@                                         	<== NOT EXECUTED
   47ae4:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47aea:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   47aec:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47af2:	2f28 0014      	movel %a0@(20),%sp@-                              	<== NOT EXECUTED

  /*
   *  WARNING!!! This is necessary to "kick" start the system and
   *             MUST be done before _Thread_Start is invoked.
   */
  _Thread_Heir      =
   47af6:	2239 0005 88ee 	movel 588ee <_Thread_Idle>,%d1                    	<== NOT EXECUTED
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   47afc:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47afe:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47b00:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   47b02:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

  /*
   *  WARNING!!! This is necessary to "kick" start the system and
   *             MUST be done before _Thread_Start is invoked.
   */
  _Thread_Heir      =
   47b08:	23c1 0005 8812 	movel %d1,58812 <_Thread_Executing>               	<== NOT EXECUTED
   47b0e:	23c1 0005 87e2 	movel %d1,587e2 <_Thread_Heir>                    	<== NOT EXECUTED
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   47b14:	4eb9 0004 8920 	jsr 48920 <_Thread_Start>                         	<== NOT EXECUTED
   47b1a:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    _Configuration_Table->idle_task,
    NULL,
    0
  );

}
   47b20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47b22:	4e75           	rts

00047b24 <_Thread_Delay_ended>:

void _Thread_Delay_ended(
  Objects_Id  id,
  void       *ignored
)
{
   47b24:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  Thread_Control    *the_thread;
  Objects_Locations  location;

  the_thread = _Thread_Get( id, &location );
   47b28:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   47b2c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47b30:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   47b36:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47b38:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   47b3c:	661e           	bnes 47b5c <_Thread_Delay_ended+0x38>             	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   47b3e:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   47b44:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47b46:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   47b4c:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47b52:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47b54:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47b56:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _Thread_Unblock( the_thread );
      _Thread_Unnest_dispatch();
      break;
  }
}
   47b5c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47b5e:	4e75           	rts

00047b60 <_Thread_Dispatch>:
 *    dispatch thread
 *    no dispatch thread
 */

void _Thread_Dispatch( void )
{
   47b60:	4e56 ffc8      	linkw %fp,#-56                                    	<== NOT EXECUTED
   47b64:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
  Thread_Control   *executing;
  Thread_Control   *heir;
  ISR_Level         level;

  executing   = _Thread_Executing;
   47b68:	2679 0005 8812 	moveal 58812 <_Thread_Executing>,%a3              	<== NOT EXECUTED
  _ISR_Disable( level );
   47b6e:	307c 0700      	moveaw #1792,%a0                                  	<== NOT EXECUTED
   47b72:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   47b74:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   47b76:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47b78:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  while ( _Context_Switch_necessary == TRUE ) {
   47b7a:	1039 0005 8822 	moveb 58822 <_Context_Switch_necessary>,%d0       	<== NOT EXECUTED
   47b80:	6700 0100      	beqw 47c82 <_Thread_Dispatch+0x122>               	<== NOT EXECUTED
   47b84:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   47b86:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
#endif
#endif

    executing = _Thread_Executing;

    _ISR_Disable( level );
   47b88:	2e08           	movel %a0,%d7                                     	<== NOT EXECUTED
   47b8a:	5183           	subql #8,%d3                                      	<== NOT EXECUTED
   47b8c:	2c3c 0004 b3a4 	movel #308132,%d6                                 	<== NOT EXECUTED
   47b92:	0682 ffff fff0 	addil #-16,%d2                                    	<== NOT EXECUTED
   47b98:	2a3c 0004 8bec 	movel #297964,%d5                                 	<== NOT EXECUTED
   47b9e:	283c 0004 8ba0 	movel #297888,%d4                                 	<== NOT EXECUTED
   47ba4:	4bf9 0004 8e94 	lea 48e94 <_User_extensions_Thread_switch>,%a5    	<== NOT EXECUTED
   47baa:	49f9 0004 921c 	lea 4921c <_CPU_Context_switch>,%a4               	<== NOT EXECUTED

  executing   = _Thread_Executing;
  _ISR_Disable( level );
  while ( _Context_Switch_necessary == TRUE ) {
    heir = _Thread_Heir;
    _Thread_Dispatch_disable_level = 1;
   47bb0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47bb2:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  ISR_Level         level;

  executing   = _Thread_Executing;
  _ISR_Disable( level );
  while ( _Context_Switch_necessary == TRUE ) {
    heir = _Thread_Heir;
   47bb8:	2479 0005 87e2 	moveal 587e2 <_Thread_Heir>,%a2                   	<== NOT EXECUTED
    _Thread_Dispatch_disable_level = 1;
    _Context_Switch_necessary = FALSE;
   47bbe:	4200           	clrb %d0                                          	<== NOT EXECUTED
   47bc0:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
    _Thread_Executing = heir;
   47bc6:	23ca 0005 8812 	movel %a2,58812 <_Thread_Executing>               	<== 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 )
   47bcc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47bce:	b0aa 007c      	cmpl %a2@(124),%d0                                	<== NOT EXECUTED
   47bd2:	6700 00da      	beqw 47cae <_Thread_Dispatch+0x14e>               	<== NOT EXECUTED
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
    _ISR_Enable( level );
   47bd6:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
   47bd8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47bda:	2046           	moveal %d6,%a0                                    	<== NOT EXECUTED
   47bdc:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   47bde:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47be0:	2045           	moveal %d5,%a0                                    	<== NOT EXECUTED
   47be2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47be4:	4879 0005 881a 	pea 5881a <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   47bea:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
        _Timespec_Add_to( &executing->cpu_time_used, &ran );
   47bec:	2044           	moveal %d4,%a0                                    	<== NOT EXECUTED
   47bee:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47bf0:	486b 0084      	pea %a3@(132)                                     	<== NOT EXECUTED
   47bf4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
    #endif

    /*
     * Switch libc's task specific data.
     */
    if ( _Thread_libc_reent ) {
   47bf6:	2079 0005 87de 	moveal 587de <_Thread_libc_reent>,%a0             	<== NOT EXECUTED
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
        _Timespec_Add_to( &executing->cpu_time_used, &ran );
        _Thread_Time_of_last_context_switch = uptime;
   47bfc:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   47c00:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
    #endif

    /*
     * Switch libc's task specific data.
     */
    if ( _Thread_libc_reent ) {
   47c04:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
        _Timespec_Add_to( &executing->cpu_time_used, &ran );
        _Thread_Time_of_last_context_switch = uptime;
   47c0a:	23c0 0005 881a 	movel %d0,5881a <_Thread_Time_of_last_context_switch>	<== NOT EXECUTED
   47c10:	23c1 0005 881e 	movel %d1,5881e <_Thread_Time_of_last_context_switch+0x4>	<== NOT EXECUTED
    #endif

    /*
     * Switch libc's task specific data.
     */
    if ( _Thread_libc_reent ) {
   47c16:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47c18:	6708           	beqs 47c22 <_Thread_Dispatch+0xc2>                	<== NOT EXECUTED
      executing->libc_reent = *_Thread_libc_reent;
   47c1a:	2750 0108      	movel %a0@,%a3@(264)                              	<== NOT EXECUTED
      *_Thread_libc_reent = heir->libc_reent;
   47c1e:	20aa 0108      	movel %a2@(264),%a0@                              	<== NOT EXECUTED
    }

    _User_extensions_Thread_switch( executing, heir );
   47c22:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47c24:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47c26:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
    if ( executing->fp_context != NULL )
      _Context_Save_fp( &executing->fp_context );
#endif
#endif

    _Context_Switch( &executing->Registers, &heir->Registers );
   47c28:	486a 00d0      	pea %a2@(208)                                     	<== NOT EXECUTED
   47c2c:	486b 00d0      	pea %a3@(208)                                     	<== NOT EXECUTED
   47c30:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
    if ( (executing->fp_context != NULL) &&
   47c32:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   47c38:	4aab 0104      	tstl %a3@(260)                                    	<== NOT EXECUTED
   47c3c:	672c           	beqs 47c6a <_Thread_Dispatch+0x10a>               	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
  const Thread_Control *the_thread
)
{
  return ( the_thread == _Thread_Allocated_fp );
   47c3e:	2079 0005 87da 	moveal 587da <_Thread_Allocated_fp>,%a0           	<== NOT EXECUTED
   47c44:	b1cb           	cmpal %a3,%a0                                     	<== NOT EXECUTED
   47c46:	6722           	beqs 47c6a <_Thread_Dispatch+0x10a>               	<== NOT EXECUTED
         !_Thread_Is_allocated_fp( executing ) ) {
      if ( _Thread_Allocated_fp != NULL )
   47c48:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47c4a:	670c           	beqs 47c58 <_Thread_Dispatch+0xf8>                	<== NOT EXECUTED
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
   47c4c:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   47c50:	4eb9 0004 9234 	jsr 49234 <_CPU_Context_save_fp>                  	<== NOT EXECUTED
   47c56:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      _Context_Restore_fp( &executing->fp_context );
   47c58:	486b 0104      	pea %a3@(260)                                     	<== NOT EXECUTED
   47c5c:	4eb9 0004 9238 	jsr 49238 <_CPU_Context_restore_fp>               	<== NOT EXECUTED
      _Thread_Allocated_fp = executing;
   47c62:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47c64:	23cb 0005 87da 	movel %a3,587da <_Thread_Allocated_fp>            	<== NOT EXECUTED
    if ( executing->fp_context != NULL )
      _Context_Restore_fp( &executing->fp_context );
#endif
#endif

    executing = _Thread_Executing;
   47c6a:	2679 0005 8812 	moveal 58812 <_Thread_Executing>,%a3              	<== NOT EXECUTED

    _ISR_Disable( level );
   47c70:	2007           	movel %d7,%d0                                     	<== NOT EXECUTED
   47c72:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   47c74:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47c76:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  Thread_Control   *heir;
  ISR_Level         level;

  executing   = _Thread_Executing;
  _ISR_Disable( level );
  while ( _Context_Switch_necessary == TRUE ) {
   47c78:	1039 0005 8822 	moveb 58822 <_Context_Switch_necessary>,%d0       	<== NOT EXECUTED
   47c7e:	6600 ff30      	bnew 47bb0 <_Thread_Dispatch+0x50>                	<== NOT EXECUTED
    executing = _Thread_Executing;

    _ISR_Disable( level );
  }

  _Thread_Dispatch_disable_level = 0;
   47c82:	42b9 0005 8754 	clrl 58754 <_Thread_Dispatch_disable_level>       	<== NOT EXECUTED

  _ISR_Enable( level );
   47c88:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Do_post_task_switch_extension ||
   47c8a:	4ab9 0005 87fa 	tstl 587fa <_Thread_Do_post_task_switch_extension>	<== NOT EXECUTED
   47c90:	6606           	bnes 47c98 <_Thread_Dispatch+0x138>               	<== NOT EXECUTED
   47c92:	4a2b 0075      	tstb %a3@(117)                                    	<== NOT EXECUTED
   47c96:	670c           	beqs 47ca4 <_Thread_Dispatch+0x144>               	<== NOT EXECUTED
       executing->do_post_task_switch_extension ) {
    executing->do_post_task_switch_extension = false;
   47c98:	4201           	clrb %d1                                          	<== NOT EXECUTED
   47c9a:	1741 0075      	moveb %d1,%a3@(117)                               	<== NOT EXECUTED
    _API_extensions_Run_postswitch();
   47c9e:	4eb9 0004 6584 	jsr 46584 <_API_extensions_Run_postswitch>        	<== NOT EXECUTED
  }

}
   47ca4:	4cee 3cfc ffc8 	moveml %fp@(-56),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   47caa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47cac:	4e75           	rts                                               	<== 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 )
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
   47cae:	41f9 0005 8704 	lea 58704 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   47cb4:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED
   47cb8:	6000 ff1c      	braw 47bd6 <_Thread_Dispatch+0x76>                	<== NOT EXECUTED

00047cbc <_Thread_Enable_dispatch>:

#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
      (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
  if ( --_Thread_Dispatch_disable_level )
   47cbc:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47cc2:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47cc4:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   47cca:	2239 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d1  	<== NOT EXECUTED
 */

#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
      (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
   47cd0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  if ( --_Thread_Dispatch_disable_level )
   47cd4:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   47cd6:	6704           	beqs 47cdc <_Thread_Enable_dispatch+0x20>         	<== NOT EXECUTED
    return;
  _Thread_Dispatch();
}
   47cd8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47cda:	4e75           	rts                                               	<== NOT EXECUTED
   47cdc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
  if ( --_Thread_Dispatch_disable_level )
    return;
  _Thread_Dispatch();
   47cde:	4ef9 0004 7b60 	jmp 47b60 <_Thread_Dispatch>                      	<== NOT EXECUTED

0004c3b8 <_Thread_Evaluate_mode>:

bool _Thread_Evaluate_mode( void )
{
  Thread_Control     *executing;

  executing = _Thread_Executing;
   4c3b8:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *
 *  XXX
 */

bool _Thread_Evaluate_mode( void )
{
   4c3be:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Thread_Control     *executing;

  executing = _Thread_Executing;

  if ( !_States_Is_ready( executing->current_state ) ||
   4c3c2:	4aa8 0010      	tstl %a0@(16)                                     	<== NOT EXECUTED
   4c3c6:	660e           	bnes 4c3d6 <_Thread_Evaluate_mode+0x1e>           	<== NOT EXECUTED
   4c3c8:	b1f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a0                    	<== NOT EXECUTED
   4c3ce:	6712           	beqs 4c3e2 <_Thread_Evaluate_mode+0x2a>           	<== NOT EXECUTED
   4c3d0:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   4c3d4:	670c           	beqs 4c3e2 <_Thread_Evaluate_mode+0x2a>           	<== NOT EXECUTED
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = TRUE;
   4c3d6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    return TRUE;
  }

  return FALSE;
}
   4c3d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  executing = _Thread_Executing;

  if ( !_States_Is_ready( executing->current_state ) ||
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = TRUE;
   4c3da:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
    return TRUE;
  }

  return FALSE;
}
   4c3e0:	4e75           	rts                                               	<== NOT EXECUTED
   4c3e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  executing = _Thread_Executing;

  if ( !_States_Is_ready( executing->current_state ) ||
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = TRUE;
    return TRUE;
   4c3e4:	4200           	clrb %d0                                          	<== NOT EXECUTED
  }

  return FALSE;
}
   4c3e6:	4e75           	rts

00047ce4 <_Thread_Get>:

Thread_Control *_Thread_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
   47ce4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47ce8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47cea:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   47cee:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47cf0:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ) {
   47cf4:	6768           	beqs 47d5e <_Thread_Get+0x7a>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
  Objects_Id id
)
{
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
   47cf6:	7018           	moveq #24,%d0                                     	<== NOT EXECUTED
   47cf8:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   47cfa:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   47cfc:	7607           	moveq #7,%d3                                      	<== NOT EXECUTED
   47cfe:	c283           	andl %d3,%d1                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   47d00:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   47d02:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47d04:	163c 0003      	moveb #3,%d3                                      	<== NOT EXECUTED
   47d08:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47d0a:	6540           	bcss 47d4c <_Thread_Get+0x68>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    goto done;
  }

  the_class = _Objects_Get_class( id );
  if ( the_class != 1 ) {       /* threads are always first class :) */
   47d0c:	761b           	moveq #27,%d3                                     	<== NOT EXECUTED
   47d0e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   47d10:	e6a8           	lsrl %d3,%d0                                      	<== NOT EXECUTED
   47d12:	163c 0001      	moveb #1,%d3                                      	<== NOT EXECUTED
   47d16:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47d18:	6632           	bnes 47d4c <_Thread_Get+0x68>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    goto done;
  }

  api_information = _Objects_Information_table[ the_api ];
   47d1a:	41f9 0005 870c 	lea 5870c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   47d20:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
  if ( !api_information ) {
   47d24:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47d26:	6724           	beqs 47d4c <_Thread_Get+0x68>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    goto done;
  }

  information = api_information[ the_class ];
   47d28:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
  if ( !information ) {
   47d2c:	6752           	beqs 47d80 <_Thread_Get+0x9c>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    goto done;
  }

  tp = (Thread_Control *) _Objects_Get( information, id, location );
   47d2e:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   47d30:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47d32:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47d34:	4eb9 0004 7438 	jsr 47438 <_Objects_Get>                          	<== NOT EXECUTED

done:
  return tp;
}
   47d3a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47d3e:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
  if ( !information ) {
    *location = OBJECTS_ERROR;
    goto done;
  }

  tp = (Thread_Control *) _Objects_Get( information, id, location );
   47d42:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

done:
  return tp;
}
   47d48:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47d4a:	4e75           	rts                                               	<== NOT EXECUTED
    goto done;
  }

  api_information = _Objects_Information_table[ the_api ];
  if ( !api_information ) {
    *location = OBJECTS_ERROR;
   47d4c:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   47d4e:	2282           	movel %d2,%a1@                                    	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d50:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47d54:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   47d58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    goto done;
  }

  api_information = _Objects_Information_table[ the_api ];
  if ( !api_information ) {
    *location = OBJECTS_ERROR;
   47d5a:	4280           	clrl %d0                                          	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d5c:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   47d5e:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47d64:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47d66:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   47d6c:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47d70:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
  Thread_Control      *tp = (Thread_Control *) 0;

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
    _Thread_Disable_dispatch();
    *location = OBJECTS_LOCAL;
    tp = _Thread_Executing;
   47d74:	2039 0005 8812 	movel 58812 <_Thread_Executing>,%d0               	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d7a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Information *information;
  Thread_Control      *tp = (Thread_Control *) 0;

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
    _Thread_Disable_dispatch();
    *location = OBJECTS_LOCAL;
   47d7c:	4291           	clrl %a1@                                         	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d7e:	4e75           	rts                                               	<== NOT EXECUTED
   47d80:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47d84:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
    goto done;
  }

  information = api_information[ the_class ];
  if ( !information ) {
    *location = OBJECTS_ERROR;
   47d88:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d8a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    goto done;
  }

  information = api_information[ the_class ];
  if ( !information ) {
    *location = OBJECTS_ERROR;
   47d8c:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED

  tp = (Thread_Control *) _Objects_Get( information, id, location );

done:
  return tp;
}
   47d8e:	4e75           	rts

0004c3e8 <_Thread_Handler>:
 *
 *  Output parameters:  NONE
 */

void _Thread_Handler( void )
{
   4c3e8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c3ec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
  static char doneConstructors;
  char doneCons;
#endif

  executing = _Thread_Executing;
   4c3ee:	2479 0005 8812 	moveal 58812 <_Thread_Executing>,%a2              	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _Thread_Handler( void )
{
   4c3f4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  /*
   * have to put level into a register for those cpu's that use
   * inline asm here
   */

  level = executing->Start.isr_level;
   4c3f6:	222a 00b6      	movel %a2@(182),%d1                               	<== NOT EXECUTED
  _ISR_Set_level(level);
   4c3fa:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4c3fc:	e189           	lsll #8,%d1                                       	<== NOT EXECUTED
   4c3fe:	0280 0000 f8ff 	andil #63743,%d0                                  	<== NOT EXECUTED
   4c404:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4c406:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
  doneCons = doneConstructors;
   4c408:	1439 0005 7f44 	moveb 57f44 <doneConstructors.4030>,%d2           	<== NOT EXECUTED
  doneConstructors = 1;
   4c40e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4c410:	13c0 0005 7f44 	moveb %d0,57f44 <doneConstructors.4030>           	<== 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 ) ) {
   4c416:	4aaa 0104      	tstl %a2@(260)                                    	<== NOT EXECUTED
   4c41a:	6720           	beqs 4c43c <_Thread_Handler+0x54>                 	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
  const Thread_Control *the_thread
)
{
  return ( the_thread == _Thread_Allocated_fp );
   4c41c:	2079 0005 87da 	moveal 587da <_Thread_Allocated_fp>,%a0           	<== NOT EXECUTED
   4c422:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   4c424:	6716           	beqs 4c43c <_Thread_Handler+0x54>                 	<== NOT EXECUTED
    if ( _Thread_Allocated_fp != NULL )
   4c426:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4c428:	670c           	beqs 4c436 <_Thread_Handler+0x4e>                 	<== NOT EXECUTED
      _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
   4c42a:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   4c42e:	4eb9 0004 9234 	jsr 49234 <_CPU_Context_save_fp>                  	<== NOT EXECUTED
   4c434:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    _Thread_Allocated_fp = executing;
   4c436:	23ca 0005 87da 	movel %a2,587da <_Thread_Allocated_fp>            	<== 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 );
   4c43c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c43e:	4eb9 0004 8cec 	jsr 48cec <_User_extensions_Thread_begin>         	<== NOT EXECUTED

  /*
   *  At this point, the dispatch disable level BETTER be 1.
   */

  _Thread_Enable_dispatch();
   4c444:	4eb9 0004 7cbc 	jsr 47cbc <_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) */
   4c44a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4c44c:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4c44e:	6760           	beqs 4c4b0 <_Thread_Handler+0xc8>                 	<== NOT EXECUTED
#if defined(__USE__MAIN__)
  if (!doneCons && _main)
    __main ();
#endif

  switch ( executing->Start.prototype ) {
   4c450:	202a 00a0      	movel %a2@(160),%d0                               	<== NOT EXECUTED
   4c454:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4c456:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c458:	6766           	beqs 4c4c0 <_Thread_Handler+0xd8>                 	<== NOT EXECUTED
   4c45a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c45c:	622a           	bhis 4c488 <_Thread_Handler+0xa0>                 	<== NOT EXECUTED
   4c45e:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   4c462:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c464:	6700 00ae      	beqw 4c514 <_Thread_Handler+0x12c>                	<== NOT EXECUTED
   4c468:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   4c46c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c46e:	6778           	beqs 4c4e8 <_Thread_Handler+0x100>                	<== 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 );
   4c470:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c472:	4eb9 0004 8d2a 	jsr 48d2a <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4c478:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4c47c:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4c480:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4c482:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
    __main ();
#endif

  switch ( executing->Start.prototype ) {
    case THREAD_START_NUMERIC:
      executing->Wait.return_argument =
   4c488:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4c48c:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4c490:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4c492:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4c496:	588f           	addql #4,%sp                                      	<== 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 );
   4c498:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c49a:	4eb9 0004 8d2a 	jsr 48d2a <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4c4a0:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4c4a4:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4c4a8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4c4aa:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
   *  in any configuration I know of and it generates a warning on every
   *  RTEMS target configuration.  --joel (12 May 2007)
   */
  if (!doneCons) /* && (volatile void *)_init) */
  {
    _init ();
   4c4b0:	4eb9 0005 53f0 	jsr 553f0 <_init>                                 	<== NOT EXECUTED
#if defined(__USE__MAIN__)
  if (!doneCons && _main)
    __main ();
#endif

  switch ( executing->Start.prototype ) {
   4c4b6:	202a 00a0      	movel %a2@(160),%d0                               	<== NOT EXECUTED
   4c4ba:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4c4bc:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c4be:	669a           	bnes 4c45a <_Thread_Handler+0x72>                 	<== NOT EXECUTED
        (*(Thread_Entry_numeric) executing->Start.entry_point)(
          executing->Start.numeric_argument
      );
      break;
    case THREAD_START_POINTER:
      executing->Wait.return_argument =
   4c4c0:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4c4c4:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4c4c8:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4c4ca:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4c4ce:	588f           	addql #4,%sp                                      	<== 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 );
   4c4d0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c4d2:	4eb9 0004 8d2a 	jsr 48d2a <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4c4d8:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4c4dc:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4c4e0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4c4e2:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
           executing->Start.pointer_argument,
           executing->Start.numeric_argument
         );
      break;
    case THREAD_START_BOTH_NUMERIC_FIRST:
      executing->Wait.return_argument =
   4c4e8:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4c4ec:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4c4f0:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4c4f4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4c4f6:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4c4fa:	508f           	addql #8,%sp                                      	<== 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 );
   4c4fc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c4fe:	4eb9 0004 8d2a 	jsr 48d2a <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4c504:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4c508:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4c50c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4c50e:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
        (*(Thread_Entry_pointer) executing->Start.entry_point)(
          executing->Start.pointer_argument
        );
      break;
    case THREAD_START_BOTH_POINTER_FIRST:
      executing->Wait.return_argument =
   4c514:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4c518:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4c51c:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4c520:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4c522:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4c526:	508f           	addql #8,%sp                                      	<== 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 );
   4c528:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c52a:	4eb9 0004 8d2a 	jsr 48d2a <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4c530:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4c534:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4c538:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4c53a:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED

00047fd4 <_Thread_Handler_initialization>:

  /*
   * BOTH stacks hooks must be set or both must be NULL.
   * Do not allow mixture.
   */
    if ( !( (!_Configuration_Table->stack_allocate_hook)
   47fd4:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47fda:	4aa8 0024      	tstl %a0@(36)                                     	<== NOT EXECUTED
   47fde:	57c1           	seq %d1                                           	<== NOT EXECUTED
   47fe0:	4aa8 0020      	tstl %a0@(32)                                     	<== NOT EXECUTED
   47fe4:	57c0           	seq %d0                                           	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  ,
  uint32_t     maximum_proxies
#endif
)
{
   47fe6:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED

  /*
   * BOTH stacks hooks must be set or both must be NULL.
   * Do not allow mixture.
   */
    if ( !( (!_Configuration_Table->stack_allocate_hook)
   47fea:	4480           	negl %d0                                          	<== NOT EXECUTED
   47fec:	4481           	negl %d1                                          	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  ,
  uint32_t     maximum_proxies
#endif
)
{
   47fee:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

  /*
   * BOTH stacks hooks must be set or both must be NULL.
   * Do not allow mixture.
   */
    if ( !( (!_Configuration_Table->stack_allocate_hook)
   47ff0:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   47ff2:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   47ff4:	6600 00b0      	bnew 480a6 <_Thread_Handler_initialization+0xd2>  	<== NOT EXECUTED

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;

  _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error(
   47ff8:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47ffa:	1039 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   48000:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   48002:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   48004:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   48006:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   48008:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4800a:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
  _Thread_Allocated_fp      = NULL;
#endif

  _Thread_Do_post_task_switch_extension = 0;

  _Thread_Maximum_extensions = maximum_extensions;
   4800c:	41ee 000c      	lea %fp@(12),%a0                                  	<== NOT EXECUTED
   48010:	23d0 0005 87f6 	movel %a0@,587f6 <_Thread_Maximum_extensions>     	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
   48016:	4200           	clrb %d0                                          	<== NOT EXECUTED

  _Thread_Do_post_task_switch_extension = 0;

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;
   48018:	41ee 0008      	lea %fp@(8),%a0                                   	<== NOT EXECUTED
   4801c:	23d0 0005 8704 	movel %a0@,58704 <_Thread_Ticks_per_timeslice>    	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
   48022:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
  _Thread_Executing         = NULL;
   48028:	42b9 0005 8812 	clrl 58812 <_Thread_Executing>                    	<== NOT EXECUTED

  _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error(
    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
  );

  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
   4802e:	4282           	clrl %d2                                          	<== NOT EXECUTED
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
  _Thread_Executing         = NULL;
  _Thread_Heir              = NULL;
   48030:	42b9 0005 87e2 	clrl 587e2 <_Thread_Heir>                         	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  _Thread_Allocated_fp      = NULL;
   48036:	42b9 0005 87da 	clrl 587da <_Thread_Allocated_fp>                 	<== NOT EXECUTED
#endif

  _Thread_Do_post_task_switch_extension = 0;
   4803c:	42b9 0005 87fa 	clrl 587fa <_Thread_Do_post_task_switch_extension>	<== NOT EXECUTED

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;

  _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error(
   48042:	4eb9 0004 9170 	jsr 49170 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
  );

  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
   48048:	1439 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d2          	<== NOT EXECUTED
   4804e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   48050:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   48052:	4281           	clrl %d1                                          	<== NOT EXECUTED

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;

  _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error(
   48054:	23c0 0005 8700 	movel %d0,58700 <_Thread_Ready_chain>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4805a:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   4805c:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4805e:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
  );

  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
   48060:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   48062:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   48066:	2148 0008      	movel %a0,%a0@(8)                                 	<== NOT EXECUTED
   4806a:	d1fc 0000 000c 	addal #12,%a0                                     	<== NOT EXECUTED
   48070:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   48072:	64e6           	bccs 4805a <_Thread_Handler_initialization+0x86>  	<== NOT EXECUTED

  /*
   *  Initialize this class of objects.
   */

  _Objects_Initialize_information(
   48074:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   48078:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4807c:	4878 0120      	pea 120 <FP_REGS_SAVED+0xe0>                      	<== NOT EXECUTED
   48080:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   48084:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   48088:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4808c:	4879 0005 88a6 	pea 588a6 <_Thread_Internal_information>          	<== NOT EXECUTED
   48092:	4eb9 0004 74ac 	jsr 474ac <_Objects_Initialize_information>       	<== NOT EXECUTED
    FALSE,                      /* TRUE if this is a global object class */
    NULL                        /* Proxy extraction support callout */
#endif
  );

}
   48098:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED

  /*
   *  Initialize this class of objects.
   */

  _Objects_Initialize_information(
   4809c:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    FALSE,                      /* TRUE if this is a global object class */
    NULL                        /* Proxy extraction support callout */
#endif
  );

}
   480a2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   480a4:	4e75           	rts                                               	<== NOT EXECUTED
   * BOTH stacks hooks must be set or both must be NULL.
   * Do not allow mixture.
   */
    if ( !( (!_Configuration_Table->stack_allocate_hook)
            == (!_Configuration_Table->stack_free_hook) ) )
    _Internal_error_Occurred(
   480a6:	4878 000f      	pea f <FPTRAP>                                    	<== NOT EXECUTED
   480aa:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   480ae:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   480b0:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
	...

00047d90 <_Thread_Initialize>:
  Thread_CPU_budget_algorithms          budget_algorithm,
  Thread_CPU_budget_algorithm_callout   budget_callout,
  uint32_t                              isr_level,
  Objects_Name                          name
)
{
   47d90:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   47d94:	48d7 047c      	moveml %d2-%d6/%a2,%sp@                           	<== NOT EXECUTED
   47d98:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   47d9c:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   47da0:	282e 001c      	movel %fp@(28),%d4                                	<== NOT EXECUTED
   47da4:	2c2e 0024      	movel %fp@(36),%d6                                	<== NOT EXECUTED
   47da8:	142e 001b      	moveb %fp@(27),%d2                                	<== NOT EXECUTED
   47dac:	1a2e 0023      	moveb %fp@(35),%d5                                	<== NOT EXECUTED
  /*
   *  Allocate and Initialize the stack for this thread.
   */


  if ( !stack_area ) {
   47db0:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   47db2:	6700 01ec      	beqw 47fa0 <_Thread_Initialize+0x210>             	<== NOT EXECUTED
    stack = the_thread->Start.stack;
    the_thread->Start.core_allocated_stack = TRUE;
  } else {
    stack = stack_area;
    actual_stack_size = stack_size;
    the_thread->Start.core_allocated_stack = FALSE;
   47db6:	202e 0014      	movel %fp@(20),%d0                                	<== NOT EXECUTED
   47dba:	4203           	clrb %d3                                          	<== NOT EXECUTED
   47dbc:	1543 00be      	moveb %d3,%a2@(190)                               	<== NOT EXECUTED
  Stack_Control *the_stack,
  void          *starting_address,
  size_t         size
)
{
  the_stack->area = starting_address;
   47dc0:	2541 00c4      	movel %d1,%a2@(196)                               	<== NOT EXECUTED
  the_stack->size = size;
   47dc4:	2540 00c0      	movel %d0,%a2@(192)                               	<== NOT EXECUTED
  /*
   *  Allocate the floating point area for this thread
   */

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( is_fp ) {
   47dc8:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   47dca:	6600 014e      	bnew 47f1a <_Thread_Initialize+0x18a>             	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   47dce:	2239 0005 87f6 	movel 587f6 <_Thread_Maximum_extensions>,%d1      	<== NOT EXECUTED
  if ( is_fp ) {

    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
    if ( !fp_area ) {
      _Thread_Stack_Free( the_thread );
      return FALSE;
   47dd4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47dd6:	4283           	clrl %d3                                          	<== NOT EXECUTED

  } else
    fp_area = NULL;

  the_thread->fp_context       = fp_area;
  the_thread->Start.fp_context = fp_area;
   47dd8:	2540 00c8      	movel %d0,%a2@(200)                               	<== NOT EXECUTED
    fp_area = _Context_Fp_start( fp_area, 0 );

  } else
    fp_area = NULL;

  the_thread->fp_context       = fp_area;
   47ddc:	2540 0104      	movel %d0,%a2@(260)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   47de0:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   47de4:	42aa 0064      	clrl %a2@(100)                                    	<== NOT EXECUTED
  the_watchdog->id        = id;
   47de8:	42aa 0068      	clrl %a2@(104)                                    	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   47dec:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED

  /*
   * Clear the libc reent hook.
   */

  the_thread->libc_reent = NULL;
   47df0:	42aa 0108      	clrl %a2@(264)                                    	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   47df4:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   47df6:	6600 015c      	bnew 47f54 <_Thread_Initialize+0x1c4>             	<== NOT EXECUTED
      return FALSE;
    }
  } else
    extensions_area = NULL;

  the_thread->extensions = (void **) extensions_area;
   47dfa:	4282           	clrl %d2                                          	<== NOT EXECUTED
   47dfc:	42aa 0118      	clrl %a2@(280)                                    	<== NOT EXECUTED

  /*
   *  General initialization
   */

  the_thread->Start.is_preemptible   = is_preemptible;
   47e00:	1545 00ac      	moveb %d5,%a2@(172)                               	<== NOT EXECUTED
  the_thread->Start.budget_algorithm = budget_algorithm;
   47e04:	2546 00ae      	movel %d6,%a2@(174)                               	<== NOT EXECUTED
  the_thread->Start.budget_callout   = budget_callout;

  switch ( budget_algorithm ) {
   47e08:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   *  General initialization
   */

  the_thread->Start.is_preemptible   = is_preemptible;
  the_thread->Start.budget_algorithm = budget_algorithm;
  the_thread->Start.budget_callout   = budget_callout;
   47e0a:	256e 0028 00b2 	movel %fp@(40),%a2@(178)                          	<== NOT EXECUTED

  switch ( budget_algorithm ) {
   47e10:	b086           	cmpl %d6,%d0                                      	<== NOT EXECUTED
   47e12:	6700 009c      	beqw 47eb0 <_Thread_Initialize+0x120>             	<== NOT EXECUTED
  the_thread->Wait.queue              = NULL;
  the_thread->resource_count          = 0;
  the_thread->suspend_count           = 0;
  the_thread->real_priority           = priority;
  the_thread->Start.initial_priority  = priority;
  _Thread_Set_priority( the_thread, priority );
   47e16:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
      break;
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
   47e18:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      break;
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      break;
  }

  the_thread->Start.isr_level         = isr_level;
   47e1a:	256e 002c 00b6 	movel %fp@(44),%a2@(182)                          	<== NOT EXECUTED

  the_thread->current_state           = STATES_DORMANT;
   47e20:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
  the_thread->Wait.queue              = NULL;
  the_thread->resource_count          = 0;
  the_thread->suspend_count           = 0;
  the_thread->real_priority           = priority;
  the_thread->Start.initial_priority  = priority;
  _Thread_Set_priority( the_thread, priority );
   47e24:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
  the_thread->Wait.queue              = NULL;
   47e26:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
  the_thread->resource_count          = 0;
   47e2a:	42aa 001c      	clrl %a2@(28)                                     	<== NOT EXECUTED
  the_thread->suspend_count           = 0;
   47e2e:	42aa 0070      	clrl %a2@(112)                                    	<== NOT EXECUTED
  the_thread->real_priority           = priority;
   47e32:	2544 0018      	movel %d4,%a2@(24)                                	<== NOT EXECUTED
  the_thread->Start.initial_priority  = priority;
   47e36:	2544 00ba      	movel %d4,%a2@(186)                               	<== NOT EXECUTED
  _Thread_Set_priority( the_thread, priority );
   47e3a:	4eb9 0004 8618 	jsr 48618 <_Thread_Set_priority>                  	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   47e40:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   47e44:	256e 0030 000c 	movel %fp@(48),%a2@(12)                           	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   47e4a:	2069 001a      	moveal %a1@(26),%a0                               	<== NOT EXECUTED
   47e4e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47e50:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   47e54:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  /*
   *  Initialize the CPU usage statistics
   */

  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
    the_thread->cpu_time_used.tv_sec  = 0;
   47e58:	42aa 0084      	clrl %a2@(132)                                    	<== NOT EXECUTED
    the_thread->cpu_time_used.tv_nsec = 0;
   47e5c:	42aa 0088      	clrl %a2@(136)                                    	<== 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 );
   47e60:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47e62:	4eb9 0004 8dbc 	jsr 48dbc <_User_extensions_Thread_create>        	<== NOT EXECUTED

  if ( !extension_status ) {
   47e68:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47e6e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   47e70:	6632           	bnes 47ea4 <_Thread_Initialize+0x114>             	<== NOT EXECUTED

    if ( extensions_area )
   47e72:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   47e74:	670a           	beqs 47e80 <_Thread_Initialize+0xf0>              	<== NOT EXECUTED
      (void) _Workspace_Free( extensions_area );
   47e76:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47e78:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   47e7e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    if ( fp_area )
   47e80:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   47e82:	670a           	beqs 47e8e <_Thread_Initialize+0xfe>              	<== NOT EXECUTED
      (void) _Workspace_Free( fp_area );
   47e84:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47e86:	4eb9 0004 9140 	jsr 49140 <_Workspace_Free>                       	<== NOT EXECUTED
   47e8c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

    _Thread_Stack_Free( the_thread );
   47e8e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47e90:	4eb9 0004 888c 	jsr 4888c <_Thread_Stack_Free>                    	<== NOT EXECUTED
   47e96:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    return FALSE;
  }

  return TRUE;

}
   47e98:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   47e9e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    if ( fp_area )
      (void) _Workspace_Free( fp_area );
#endif

    _Thread_Stack_Free( the_thread );
   47ea0:	4200           	clrb %d0                                          	<== NOT EXECUTED
    return FALSE;
  }

  return TRUE;

}
   47ea2:	4e75           	rts                                               	<== NOT EXECUTED
   47ea4:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   47eaa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *  Mutex provides sufficient protection to let the user extensions
   *  run safely.
   */
  extension_status = _User_extensions_Thread_create( the_thread );

  if ( !extension_status ) {
   47eac:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    return FALSE;
  }

  return TRUE;

}
   47eae:	4e75           	rts                                               	<== NOT EXECUTED
  switch ( budget_algorithm ) {
    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;
   47eb0:	41f9 0005 8704 	lea 58704 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   47eb6:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED
      break;
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
   47eba:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  the_thread->Wait.queue              = NULL;
  the_thread->resource_count          = 0;
  the_thread->suspend_count           = 0;
  the_thread->real_priority           = priority;
  the_thread->Start.initial_priority  = priority;
  _Thread_Set_priority( the_thread, priority );
   47ebc:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
      break;
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      break;
  }

  the_thread->Start.isr_level         = isr_level;
   47ebe:	256e 002c 00b6 	movel %fp@(44),%a2@(182)                          	<== NOT EXECUTED

  the_thread->current_state           = STATES_DORMANT;
   47ec4:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
  the_thread->Wait.queue              = NULL;
  the_thread->resource_count          = 0;
  the_thread->suspend_count           = 0;
  the_thread->real_priority           = priority;
  the_thread->Start.initial_priority  = priority;
  _Thread_Set_priority( the_thread, priority );
   47ec8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
  the_thread->Wait.queue              = NULL;
   47eca:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
  the_thread->resource_count          = 0;
   47ece:	42aa 001c      	clrl %a2@(28)                                     	<== NOT EXECUTED
  the_thread->suspend_count           = 0;
   47ed2:	42aa 0070      	clrl %a2@(112)                                    	<== NOT EXECUTED
  the_thread->real_priority           = priority;
   47ed6:	2544 0018      	movel %d4,%a2@(24)                                	<== NOT EXECUTED
  the_thread->Start.initial_priority  = priority;
   47eda:	2544 00ba      	movel %d4,%a2@(186)                               	<== NOT EXECUTED
  _Thread_Set_priority( the_thread, priority );
   47ede:	4eb9 0004 8618 	jsr 48618 <_Thread_Set_priority>                  	<== NOT EXECUTED
   47ee4:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   47ee8:	256e 0030 000c 	movel %fp@(48),%a2@(12)                           	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   47eee:	2069 001a      	moveal %a1@(26),%a0                               	<== NOT EXECUTED
   47ef2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47ef4:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   47ef8:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  /*
   *  Initialize the CPU usage statistics
   */

  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
    the_thread->cpu_time_used.tv_sec  = 0;
   47efc:	42aa 0084      	clrl %a2@(132)                                    	<== NOT EXECUTED
    the_thread->cpu_time_used.tv_nsec = 0;
   47f00:	42aa 0088      	clrl %a2@(136)                                    	<== 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 );
   47f04:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47f06:	4eb9 0004 8dbc 	jsr 48dbc <_User_extensions_Thread_create>        	<== NOT EXECUTED

  if ( !extension_status ) {
   47f0c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47f12:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   47f14:	6700 ff5c      	beqw 47e72 <_Thread_Initialize+0xe2>              	<== NOT EXECUTED
   47f18:	608a           	bras 47ea4 <_Thread_Initialize+0x114>             	<== NOT EXECUTED
   */

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( is_fp ) {

    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
   47f1a:	4878 001c      	pea 1c <OPER2+0x8>                                	<== NOT EXECUTED
   47f1e:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED
    if ( !fp_area ) {
   47f24:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   */

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( is_fp ) {

    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
   47f26:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
    if ( !fp_area ) {
   47f28:	6700 ff64      	beqw 47e8e <_Thread_Initialize+0xfe>              	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   47f2c:	2239 0005 87f6 	movel 587f6 <_Thread_Maximum_extensions>,%d1      	<== NOT EXECUTED

  } else
    fp_area = NULL;

  the_thread->fp_context       = fp_area;
  the_thread->Start.fp_context = fp_area;
   47f32:	2540 00c8      	movel %d0,%a2@(200)                               	<== NOT EXECUTED
    fp_area = _Context_Fp_start( fp_area, 0 );

  } else
    fp_area = NULL;

  the_thread->fp_context       = fp_area;
   47f36:	2540 0104      	movel %d0,%a2@(260)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   47f3a:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   47f3e:	42aa 0064      	clrl %a2@(100)                                    	<== NOT EXECUTED
  the_watchdog->id        = id;
   47f42:	42aa 0068      	clrl %a2@(104)                                    	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   47f46:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED

  /*
   * Clear the libc reent hook.
   */

  the_thread->libc_reent = NULL;
   47f4a:	42aa 0108      	clrl %a2@(264)                                    	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   47f4e:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   47f50:	6700 fea8      	beqw 47dfa <_Thread_Initialize+0x6a>              	<== NOT EXECUTED
    extensions_area = _Workspace_Allocate(
   47f54:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   47f56:	2041           	moveal %d1,%a0                                    	<== NOT EXECUTED
   47f58:	4868 0004      	pea %a0@(4)                                       	<== NOT EXECUTED
   47f5c:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED
      (_Thread_Maximum_extensions + 1) * sizeof( void * )
    );

    if ( !extensions_area ) {
   47f62:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
    extensions_area = _Workspace_Allocate(
   47f64:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
      (_Thread_Maximum_extensions + 1) * sizeof( void * )
    );

    if ( !extensions_area ) {
   47f66:	6700 ff18      	beqw 47e80 <_Thread_Initialize+0xf0>              	<== NOT EXECUTED
      return FALSE;
    }
  } else
    extensions_area = NULL;

  the_thread->extensions = (void **) extensions_area;
   47f6a:	2540 0118      	movel %d0,%a2@(280)                               	<== NOT EXECUTED
   * call.
   */

  if ( the_thread->extensions ) {
    uint32_t i;
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
   47f6e:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
   47f70:	b0b9 0005 87f6 	cmpl 587f6 <_Thread_Maximum_extensions>,%d0       	<== NOT EXECUTED
   47f76:	6700 fe88      	beqw 47e00 <_Thread_Initialize+0x70>              	<== NOT EXECUTED
   47f7a:	2239 0005 87f6 	movel 587f6 <_Thread_Maximum_extensions>,%d1      	<== NOT EXECUTED
   47f80:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47f82:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   47f84:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
      the_thread->extensions[i] = NULL;
   47f86:	42b0 0c00      	clrl %a0@(00000000,%d0:l:4)                       	<== NOT EXECUTED
   * call.
   */

  if ( the_thread->extensions ) {
    uint32_t i;
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
   47f8a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47f8c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47f8e:	6400 fe70      	bccw 47e00 <_Thread_Initialize+0x70>              	<== NOT EXECUTED
      the_thread->extensions[i] = NULL;
   47f92:	42b0 0c00      	clrl %a0@(00000000,%d0:l:4)                       	<== NOT EXECUTED
   * call.
   */

  if ( the_thread->extensions ) {
    uint32_t i;
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
   47f96:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   47f98:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47f9a:	65ea           	bcss 47f86 <_Thread_Initialize+0x1f6>             	<== NOT EXECUTED
   47f9c:	6000 fe62      	braw 47e00 <_Thread_Initialize+0x70>              	<== NOT EXECUTED
   */


  if ( !stack_area ) {

    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
   47fa0:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   47fa4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47fa6:	4eb9 0004 8824 	jsr 48824 <_Thread_Stack_Allocate>                	<== NOT EXECUTED

    if ( !actual_stack_size || actual_stack_size < stack_size )
   47fac:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47fae:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47fb0:	6714           	beqs 47fc6 <_Thread_Initialize+0x236>             	<== NOT EXECUTED
   47fb2:	b0ae 0014      	cmpl %fp@(20),%d0                                 	<== NOT EXECUTED
   47fb6:	650e           	bcss 47fc6 <_Thread_Initialize+0x236>             	<== NOT EXECUTED
      return FALSE;                     /* stack allocation failed */

    stack = the_thread->Start.stack;
   47fb8:	222a 00cc      	movel %a2@(204),%d1                               	<== NOT EXECUTED
    the_thread->Start.core_allocated_stack = TRUE;
   47fbc:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   47fbe:	1543 00be      	moveb %d3,%a2@(190)                               	<== NOT EXECUTED
   47fc2:	6000 fdfc      	braw 47dc0 <_Thread_Initialize+0x30>              	<== NOT EXECUTED
    return FALSE;
  }

  return TRUE;

}
   47fc6:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   47fcc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      (void) _Workspace_Free( fp_area );
#endif

    _Thread_Stack_Free( the_thread );

    return FALSE;
   47fce:	4200           	clrb %d0                                          	<== NOT EXECUTED
  }

  return TRUE;

}
   47fd0:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b700 <_Thread_Load_environment>:
 */

void _Thread_Load_environment(
  Thread_Control *the_thread
)
{
   4b700:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b704:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  bool is_fp;

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( the_thread->Start.fp_context ) {
   4b708:	2069 00c8      	moveal %a1@(200),%a0                              	<== NOT EXECUTED
   4b70c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4b70e:	6734           	beqs 4b744 <_Thread_Load_environment+0x44>        	<== NOT EXECUTED
    the_thread->fp_context = the_thread->Start.fp_context;
   4b710:	2348 0104      	movel %a0,%a1@(260)                               	<== NOT EXECUTED
    _Context_Initialize_fp( &the_thread->fp_context );
   4b714:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4b716:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b718:	2141 0018      	movel %d1,%a0@(24)                                	<== NOT EXECUTED
   4b71c:	4241           	clrw %d1                                          	<== NOT EXECUTED
   4b71e:	2140 0014      	movel %d0,%a0@(20)                                	<== NOT EXECUTED
   4b722:	3141 0002      	movew %d1,%a0@(2)                                 	<== NOT EXECUTED
   4b726:	3141 0004      	movew %d1,%a0@(4)                                 	<== NOT EXECUTED
   4b72a:	3141 0006      	movew %d1,%a0@(6)                                 	<== NOT EXECUTED
   4b72e:	3141 0008      	movew %d1,%a0@(8)                                 	<== NOT EXECUTED
   4b732:	3141 000a      	movew %d1,%a0@(10)                                	<== NOT EXECUTED
   4b736:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b738:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4b73a:	4250           	clrw %a0@                                         	<== NOT EXECUTED
   4b73c:	2140 000c      	movel %d0,%a0@(12)                                	<== NOT EXECUTED
   4b740:	2141 0010      	movel %d1,%a0@(16)                                	<== NOT EXECUTED
  the_thread->do_post_task_switch_extension = false;
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
  the_thread->budget_callout   = the_thread->Start.budget_callout;

  _Context_Initialize(
   4b744:	2069 00c0      	moveal %a1@(192),%a0                              	<== NOT EXECUTED
   4b748:	5988           	subql #4,%a0                                      	<== NOT EXECUTED
   4b74a:	d1e9 00c4      	addal %a1@(196),%a0                               	<== NOT EXECUTED
   4b74e:	2029 00b6      	movel %a1@(182),%d0                               	<== NOT EXECUTED
   4b752:	2348 0100      	movel %a0,%a1@(256)                               	<== NOT EXECUTED
   4b756:	e188           	lsll #8,%d0                                       	<== NOT EXECUTED
   4b758:	0080 0000 3000 	oril #12288,%d0                                   	<== NOT EXECUTED
  } else
#endif
    is_fp = false;


  the_thread->do_post_task_switch_extension = false;
   4b75e:	4201           	clrb %d1                                          	<== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
   4b760:	2369 00ae 007c 	movel %a1@(174),%a1@(124)                         	<== NOT EXECUTED
    the_thread->Start.isr_level,
    _Thread_Handler,
    is_fp
  );

}
   4b766:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  the_thread->do_post_task_switch_extension = false;
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
  the_thread->budget_callout   = the_thread->Start.budget_callout;
   4b768:	2369 00b2 0080 	movel %a1@(178),%a1@(128)                         	<== NOT EXECUTED
  } else
#endif
    is_fp = false;


  the_thread->do_post_task_switch_extension = false;
   4b76e:	1341 0075      	moveb %d1,%a1@(117)                               	<== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
   4b772:	1369 00ac 0076 	moveb %a1@(172),%a1@(118)                         	<== NOT EXECUTED
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
  the_thread->budget_callout   = the_thread->Start.budget_callout;

  _Context_Initialize(
   4b778:	2340 00d0      	movel %d0,%a1@(208)                               	<== NOT EXECUTED
   4b77c:	20bc 0004 c3e8 	movel #312296,%a0@                                	<== NOT EXECUTED
    the_thread->Start.isr_level,
    _Thread_Handler,
    is_fp
  );

}
   4b782:	4e75           	rts

0004b9ec <_Thread_Ready>:
 */

void _Thread_Ready(
  Thread_Control *the_thread
)
{
   4b9ec:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4b9f0:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );
   4b9f4:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
 */

void _Thread_Ready(
  Thread_Control *the_thread
)
{
   4b9fa:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );
   4b9fe:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4ba00:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   4ba02:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4ba04:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  the_thread->current_state = STATES_READY;

  _Priority_Add_to_bit_map( &the_thread->Priority_map );

  _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
   4ba06:	2268 008c      	moveal %a0@(140),%a1                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4ba0a:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor |= the_priority_map->ready_minor;
   4ba0c:	2468 0090      	moveal %a0@(144),%a2                              	<== NOT EXECUTED
   4ba10:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4ba12:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   4ba14:	2669 0008      	moveal %a1@(8),%a3                                	<== NOT EXECUTED
   4ba18:	3228 0096      	movew %a0@(150),%d1                               	<== NOT EXECUTED
   4ba1c:	3012           	movew %a2@,%d0                                    	<== NOT EXECUTED
   4ba1e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4ba20:	3480           	movew %d0,%a2@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   4ba22:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   4ba26:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4ba2c:	3228 0094      	movew %a0@(148),%d1                               	<== NOT EXECUTED
   4ba30:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4ba32:	214b 0004      	movel %a3,%a0@(4)                                 	<== NOT EXECUTED
   4ba36:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );

  the_thread->current_state = STATES_READY;
   4ba3c:	42a8 0010      	clrl %a0@(16)                                     	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   4ba40:	2688           	movel %a0,%a3@                                    	<== NOT EXECUTED

  _Priority_Add_to_bit_map( &the_thread->Priority_map );

  _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );

  _ISR_Flash( level );
   4ba42:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   4ba44:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
   4ba46:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
  Priority_Bit_map_control minor;
  Priority_Bit_map_control major;

  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
   4ba48:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4ba4e:	4840           	swap %d0                                          	<== NOT EXECUTED
   4ba50:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   4ba52:	41f9 0005 8878 	lea 58878 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   4ba58:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   4ba5e:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   4ba62:	4841           	swap %d1                                          	<== NOT EXECUTED
   4ba64:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   4ba66:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   4ba6c:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   4ba6e:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4ba70:	2079 0005 8700 	moveal 58700 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   4ba76:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4ba78:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4ba7a:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   4ba7c:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   4ba7e:	2230 2800      	movel %a0@(00000000,%d2:l),%d1                    	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
  const Thread_Control *the_thread
)
{
  return ( the_thread == _Thread_Executing );
   4ba82:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   4ba88:	23c1 0005 87e2 	movel %d1,587e2 <_Thread_Heir>                    	<== NOT EXECUTED

  _Thread_Calculate_heir();

  heir = _Thread_Heir;

  if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible )
   4ba8e:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   4ba90:	670e           	beqs 4baa0 <_Thread_Ready+0xb4>                   	<== NOT EXECUTED
   4ba92:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   4ba96:	6708           	beqs 4baa0 <_Thread_Ready+0xb4>                   	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;
   4ba98:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ba9a:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   4baa0:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   4baa2:	4cd7 0c0c      	moveml %sp@,%d2-%d3/%a2-%a3                       	<== NOT EXECUTED
   4baa6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4baa8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c4e8 <_Thread_Reset>:
void _Thread_Reset(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   4c4e8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c4ec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c4ee:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
  the_thread->budget_callout   = the_thread->Start.budget_callout;

  the_thread->Start.pointer_argument = pointer_argument;
  the_thread->Start.numeric_argument = numeric_argument;
   4c4f2:	256e 0010 00a8 	movel %fp@(16),%a2@(168)                          	<== NOT EXECUTED
  the_thread->suspend_count    = 0;
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
  the_thread->budget_callout   = the_thread->Start.budget_callout;

  the_thread->Start.pointer_argument = pointer_argument;
   4c4f8:	256e 000c 00a4 	movel %fp@(12),%a2@(164)                          	<== NOT EXECUTED
  Thread_Entry_numeric_type  numeric_argument
)
{
  the_thread->resource_count   = 0;
  the_thread->suspend_count    = 0;
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
   4c4fe:	156a 00ac 0076 	moveb %a2@(172),%a2@(118)                         	<== NOT EXECUTED
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
  the_thread->resource_count   = 0;
   4c504:	42aa 001c      	clrl %a2@(28)                                     	<== NOT EXECUTED
  the_thread->suspend_count    = 0;
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
   4c508:	256a 00ae 007c 	movel %a2@(174),%a2@(124)                         	<== NOT EXECUTED
  the_thread->budget_callout   = the_thread->Start.budget_callout;
   4c50e:	256a 00b2 0080 	movel %a2@(178),%a2@(128)                         	<== NOT EXECUTED
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
  the_thread->resource_count   = 0;
  the_thread->suspend_count    = 0;
   4c514:	42aa 0070      	clrl %a2@(112)                                    	<== NOT EXECUTED
  the_thread->budget_callout   = the_thread->Start.budget_callout;

  the_thread->Start.pointer_argument = pointer_argument;
  the_thread->Start.numeric_argument = numeric_argument;

  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
   4c518:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c51a:	4eb9 0004 8db8 	jsr 48db8 <_Thread_queue_Extract_with_proxy>      	<== NOT EXECUTED
   4c520:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4c522:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4c524:	6608           	bnes 4c52e <_Thread_Reset+0x46>                   	<== NOT EXECUTED

    if ( _Watchdog_Is_active( &the_thread->Timer ) )
   4c526:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4c528:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4c52c:	672a           	beqs 4c558 <_Thread_Reset+0x70>                   	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );
  }

  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
   4c52e:	202a 00ba      	movel %a2@(186),%d0                               	<== NOT EXECUTED
   4c532:	b0aa 0014      	cmpl %a2@(20),%d0                                 	<== NOT EXECUTED
   4c536:	6718           	beqs 4c550 <_Thread_Reset+0x68>                   	<== NOT EXECUTED
    the_thread->real_priority = the_thread->Start.initial_priority;
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
   4c538:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
   4c53c:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
    if ( _Watchdog_Is_active( &the_thread->Timer ) )
      (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;
   4c540:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
  }
}
   4c544:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4c548:	4e5e           	unlk %fp                                          	<== 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 );
   4c54a:	4ef9 0004 9010 	jmp 49010 <_Thread_Set_priority>                  	<== NOT EXECUTED
  }
}
   4c550:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4c554:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c556:	4e75           	rts                                               	<== NOT EXECUTED
  the_thread->Start.numeric_argument = numeric_argument;

  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {

    if ( _Watchdog_Is_active( &the_thread->Timer ) )
      (void) _Watchdog_Remove( &the_thread->Timer );
   4c558:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4c55c:	4eb9 0004 9a58 	jsr 49a58 <_Watchdog_Remove>                      	<== NOT EXECUTED
   4c562:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4c564:	60c8           	bras 4c52e <_Thread_Reset+0x46>                   	<== NOT EXECUTED
	...

0004baac <_Thread_Reset_timeslice>:
 *    ready chain
 *    select heir
 */

void _Thread_Reset_timeslice( void )
{
   4baac:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4bab0:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
   4bab4:	2679 0005 8812 	moveal 58812 <_Thread_Executing>,%a3              	<== NOT EXECUTED
  ready     = executing->ready;
  _ISR_Disable( level );
   4baba:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
  ready     = executing->ready;
   4bac0:	286b 008c      	moveal %a3@(140),%a4                              	<== NOT EXECUTED
  _ISR_Disable( level );
   4bac4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4bac6:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4bac8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4baca:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( _Chain_Has_only_one_node( ready ) ) {
   4bacc:	202c 0008      	movel %a4@(8),%d0                                 	<== NOT EXECUTED
   4bad0:	b094           	cmpl %a4@,%d0                                     	<== NOT EXECUTED
   4bad2:	6754           	beqs 4bb28 <_Thread_Reset_timeslice+0x7c>         	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   4bad4:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   4bad6:	226b 0004      	moveal %a3@(4),%a1                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   4bada:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4badc:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   4bade:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4bae0:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4bae2:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
   4bae6:	246c 0008      	moveal %a4@(8),%a2                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   4baea:	294b 0008      	movel %a3,%a4@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4baee:	274a 0004      	movel %a2,%a3@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   4baf2:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED
      return;
    }
    _Chain_Extract_unprotected( &executing->Object.Node );
    _Chain_Append_unprotected( ready, &executing->Object.Node );

  _ISR_Flash( level );
   4baf4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4baf6:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4baf8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4bafa:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    if ( _Thread_Is_heir( executing ) )
   4bafc:	b7f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a3                    	<== NOT EXECUTED
   4bb02:	6712           	beqs 4bb16 <_Thread_Reset_timeslice+0x6a>         	<== NOT EXECUTED
      _Thread_Heir = (Thread_Control *) ready->first;

    _Context_Switch_necessary = TRUE;
   4bb04:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4bb06:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   4bb0c:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   4bb0e:	4cd7 1c04      	moveml %sp@,%d2/%a2-%a4                           	<== NOT EXECUTED
   4bb12:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bb14:	4e75           	rts                                               	<== NOT EXECUTED
    _Chain_Append_unprotected( ready, &executing->Object.Node );

  _ISR_Flash( level );

    if ( _Thread_Is_heir( executing ) )
      _Thread_Heir = (Thread_Control *) ready->first;
   4bb16:	23d4 0005 87e2 	movel %a4@,587e2 <_Thread_Heir>                   	<== NOT EXECUTED

    _Context_Switch_necessary = TRUE;
   4bb1c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4bb1e:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   4bb24:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4bb26:	60e6           	bras 4bb0e <_Thread_Reset_timeslice+0x62>         	<== NOT EXECUTED

  executing = _Thread_Executing;
  ready     = executing->ready;
  _ISR_Disable( level );
    if ( _Chain_Has_only_one_node( ready ) ) {
      _ISR_Enable( level );
   4bb28:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      _Thread_Heir = (Thread_Control *) ready->first;

    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
}
   4bb2a:	4cd7 1c04      	moveml %sp@,%d2/%a2-%a4                           	<== NOT EXECUTED
   4bb2e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bb30:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048f5c <_Thread_Restart>:
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   48f5c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48f60:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48f62:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   48f66:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   48f68:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   48f6a:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED
   48f6e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   48f70:	6710           	beqs 48f82 <_Thread_Restart+0x26>                 	<== NOT EXECUTED
   48f72:	4202           	clrb %d2                                          	<== NOT EXECUTED

    return TRUE;
  }

  return FALSE;
}
   48f74:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   48f76:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48f7a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48f7e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48f80:	4e75           	rts                                               	<== NOT EXECUTED
  Thread_Entry_numeric_type  numeric_argument
)
{
  if ( !_States_Is_dormant( the_thread->current_state ) ) {

    _Thread_Set_transient( the_thread );
   48f82:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48f84:	4eb9 0004 9194 	jsr 49194 <_Thread_Set_transient>                 	<== NOT EXECUTED

    _Thread_Reset( the_thread, pointer_argument, numeric_argument );
   48f8a:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   48f8e:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   48f92:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48f94:	4eb9 0004 c4e8 	jsr 4c4e8 <_Thread_Reset>                         	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );
   48f9a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48f9c:	4eb9 0004 c13c 	jsr 4c13c <_Thread_Load_environment>              	<== NOT EXECUTED

    _Thread_Ready( the_thread );
   48fa2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48fa4:	4eb9 0004 c428 	jsr 4c428 <_Thread_Ready>                         	<== NOT EXECUTED

    _User_extensions_Thread_restart( the_thread );
   48faa:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48fac:	4eb9 0004 9848 	jsr 49848 <_User_extensions_Thread_restart>       	<== NOT EXECUTED

    if ( _Thread_Is_executing ( the_thread ) )
   48fb2:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   48fb8:	b5f9 0005 a34a 	cmpal 5a34a <_Thread_Executing>,%a2               	<== NOT EXECUTED
   48fbe:	6710           	beqs 48fd0 <_Thread_Restart+0x74>                 	<== NOT EXECUTED
   48fc0:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED

    return TRUE;
  }

  return FALSE;
}
   48fc2:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   48fc4:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48fc8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48fcc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48fce:	4e75           	rts                                               	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( _Thread_Executing->fp_context != NULL )
   48fd0:	4aaa 0104      	tstl %a2@(260)                                    	<== NOT EXECUTED
   48fd4:	670c           	beqs 48fe2 <_Thread_Restart+0x86>                 	<== NOT EXECUTED
    _Context_Restore_fp( &_Thread_Executing->fp_context );
   48fd6:	486a 0104      	pea %a2@(260)                                     	<== NOT EXECUTED
   48fda:	4eb9 0004 9c74 	jsr 49c74 <_CPU_Context_restore_fp>               	<== NOT EXECUTED
   48fe0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

  _CPU_Context_Restart_self( &_Thread_Executing->Registers );
   48fe2:	2079 0005 a34a 	moveal 5a34a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   48fe8:	2228 00d0      	movel %a0@(208),%d1                               	<== NOT EXECUTED
   48fec:	2028 0100      	movel %a0@(256),%d0                               	<== NOT EXECUTED
   48ff0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   48ff2:	2e40           	moveal %d0,%sp                                    	<== NOT EXECUTED
   48ff4:	4e75           	rts                                               	<== NOT EXECUTED
   48ff6:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   48ff8:	2140 0100      	movel %d0,%a0@(256)                               	<== NOT EXECUTED
   48ffc:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   48ffe:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   49002:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   49006:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49008:	2141 00d0      	movel %d1,%a0@(208)                               	<== NOT EXECUTED
   4900c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049b20 <_Thread_Resume>:

void _Thread_Resume(
  Thread_Control   *the_thread,
  bool              force
)
{
   49b20:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   49b24:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   49b28:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   49b2c:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED

  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   49b30:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   49b36:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   49b38:	8282           	orl %d2,%d1                                       	<== NOT EXECUTED
   49b3a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  if ( force == TRUE )
   49b3c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49b3e:	6700 0092      	beqw 49bd2 <_Thread_Resume+0xb2>                  	<== NOT EXECUTED
    the_thread->suspend_count = 0;
   49b42:	42ab 0070      	clrl %a3@(112)                                    	<== NOT EXECUTED
  if ( the_thread->suspend_count > 0 ) {
    _ISR_Enable( level );
    return;
  }

  current_state = the_thread->current_state;
   49b46:	202b 0010      	movel %a3@(16),%d0                                	<== NOT EXECUTED
  if ( current_state & STATES_SUSPENDED ) {
   49b4a:	0800 0001      	btst #1,%d0                                       	<== NOT EXECUTED
   49b4e:	6778           	beqs 49bc8 <_Thread_Resume+0xa8>                  	<== NOT EXECUTED
   49b50:	72fd           	moveq #-3,%d1                                     	<== NOT EXECUTED
   49b52:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
    current_state =
   49b54:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
    the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);

    if ( _States_Is_ready( current_state ) ) {
   49b58:	666e           	bnes 49bc8 <_Thread_Resume+0xa8>                  	<== NOT EXECUTED

      _Priority_Add_to_bit_map( &the_thread->Priority_map );

      _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
   49b5a:	206b 008c      	moveal %a3@(140),%a0                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   49b5e:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor |= the_priority_map->ready_minor;
   49b60:	226b 0090      	moveal %a3@(144),%a1                              	<== NOT EXECUTED
   49b64:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   49b66:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   49b68:	2468 0008      	moveal %a0@(8),%a2                                	<== NOT EXECUTED
   49b6c:	322b 0096      	movew %a3@(150),%d1                               	<== NOT EXECUTED
   49b70:	3011           	movew %a1@,%d0                                    	<== NOT EXECUTED
   49b72:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49b74:	3280           	movew %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   49b76:	214b 0008      	movel %a3,%a0@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   49b7a:	3039 0006 2e30 	movew 62e30 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   49b80:	322b 0094      	movew %a3@(148),%d1                               	<== NOT EXECUTED
   49b84:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49b86:	33c0 0006 2e30 	movew %d0,62e30 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   49b8c:	274a 0004      	movel %a2,%a3@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   49b90:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED

      _ISR_Flash( level );
   49b92:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   49b98:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49b9a:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   49b9c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
   49b9e:	2079 0006 2e0a 	moveal 62e0a <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   49ba4:	202b 0014      	movel %a3@(20),%d0                                	<== NOT EXECUTED
   49ba8:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   49bac:	641a           	bccs 49bc8 <_Thread_Resume+0xa8>                  	<== NOT EXECUTED
        _Thread_Heir = the_thread;
        if ( _Thread_Executing->is_preemptible ||
   49bae:	2079 0006 2e3a 	moveal 62e3a <_Thread_Executing>,%a0              	<== NOT EXECUTED
      _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);

      _ISR_Flash( level );

      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
        _Thread_Heir = the_thread;
   49bb4:	23cb 0006 2e0a 	movel %a3,62e0a <_Thread_Heir>                    	<== NOT EXECUTED
        if ( _Thread_Executing->is_preemptible ||
   49bba:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   49bbe:	672a           	beqs 49bea <_Thread_Resume+0xca>                  	<== NOT EXECUTED
             the_thread->current_priority == 0 )
          _Context_Switch_necessary = TRUE;
   49bc0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49bc2:	13c1 0006 2e4a 	moveb %d1,62e4a <_Context_Switch_necessary>       	<== NOT EXECUTED
      }
    }
  }

  _ISR_Enable( level );
   49bc8:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   49bca:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   49bce:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49bd0:	4e75           	rts                                               	<== NOT EXECUTED
  _ISR_Disable( level );

  if ( force == TRUE )
    the_thread->suspend_count = 0;
  else
    the_thread->suspend_count--;
   49bd2:	202b 0070      	movel %a3@(112),%d0                               	<== NOT EXECUTED
   49bd6:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   49bd8:	2740 0070      	movel %d0,%a3@(112)                               	<== NOT EXECUTED

  if ( the_thread->suspend_count > 0 ) {
   49bdc:	6700 ff68      	beqw 49b46 <_Thread_Resume+0x26>                  	<== NOT EXECUTED
    _ISR_Enable( level );
   49be0:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
      }
    }
  }

  _ISR_Enable( level );
}
   49be2:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   49be6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49be8:	4e75           	rts                                               	<== NOT EXECUTED

      _ISR_Flash( level );

      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
        _Thread_Heir = the_thread;
        if ( _Thread_Executing->is_preemptible ||
   49bea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49bec:	66da           	bnes 49bc8 <_Thread_Resume+0xa8>                  	<== NOT EXECUTED
             the_thread->current_priority == 0 )
          _Context_Switch_necessary = TRUE;
   49bee:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49bf0:	13c1 0006 2e4a 	moveb %d1,62e4a <_Context_Switch_necessary>       	<== NOT EXECUTED
   49bf6:	60d0           	bras 49bc8 <_Thread_Resume+0xa8>                  	<== NOT EXECUTED

00048618 <_Thread_Set_priority>:

void _Thread_Set_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority
)
{
   48618:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4861c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   48620:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   48624:	48d7 003c      	moveml %d2-%d5,%sp@                               	<== NOT EXECUTED
  the_thread->current_priority = new_priority;
  the_thread->ready            = &_Thread_Ready_chain[ new_priority ];
   48628:	2a00           	movel %d0,%d5                                     	<== NOT EXECUTED
   4862a:	2800           	movel %d0,%d4                                     	<== NOT EXECUTED
{
  Priority_Bit_map_control major;
  Priority_Bit_map_control minor;
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
   4862c:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   4862e:	720f           	moveq #15,%d1                                     	<== NOT EXECUTED
void _Thread_Set_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority
)
{
  the_thread->current_priority = new_priority;
   48630:	2140 0014      	movel %d0,%a0@(20)                                	<== NOT EXECUTED
  the_thread->ready            = &_Thread_Ready_chain[ new_priority ];
   48634:	e58d           	lsll #2,%d5                                       	<== NOT EXECUTED
   48636:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   48638:	e98c           	lsll #4,%d4                                       	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
   4863a:	323c 8000      	movew #-32768,%d1                                 	<== NOT EXECUTED
   4863e:	9885           	subl %d5,%d4                                      	<== NOT EXECUTED
{
  Priority_Bit_map_control major;
  Priority_Bit_map_control minor;
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
   48640:	e88b           	lsrl #4,%d3                                       	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   48642:	0283 0000 ffff 	andil #65535,%d3                                  	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   48648:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   4864a:	d8b9 0005 8700 	addl 58700 <_Thread_Ready_chain>,%d4              	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
   48650:	e6a1           	asrl %d3,%d1                                      	<== NOT EXECUTED
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   48652:	e0a2           	asrl %d0,%d2                                      	<== NOT EXECUTED
  the_priority_map->ready_minor = mask;
   48654:	3142 0096      	movew %d2,%a0@(150)                               	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   48658:	d683           	addl %d3,%d3                                      	<== NOT EXECUTED
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
  the_priority_map->ready_minor = mask;
  the_priority_map->block_minor = ~mask;
   4865a:	4682           	notl %d2                                          	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   4865c:	0683 0005 8878 	addil #362616,%d3                                 	<== NOT EXECUTED
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
  the_priority_map->ready_minor = mask;
  the_priority_map->block_minor = ~mask;
   48662:	3142 009a      	movew %d2,%a0@(154)                               	<== NOT EXECUTED
   48666:	2144 008c      	movel %d4,%a0@(140)                               	<== NOT EXECUTED

  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
   4866a:	3141 0094      	movew %d1,%a0@(148)                               	<== NOT EXECUTED
  the_priority_map->block_major = ~mask;
   4866e:	4681           	notl %d1                                          	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   48670:	2143 0090      	movel %d3,%a0@(144)                               	<== NOT EXECUTED

  _Priority_Initialize_information( &the_thread->Priority_map, new_priority );
}
   48674:	4cd7 003c      	moveml %sp@,%d2-%d5                               	<== NOT EXECUTED
   48678:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;
   4867a:	3141 0098      	movew %d1,%a0@(152)                               	<== NOT EXECUTED
   4867e:	4e75           	rts

00048680 <_Thread_Set_state>:

void _Thread_Set_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   48680:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   48684:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   48688:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   4868c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
)
{
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
   48692:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   48696:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   48698:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4869a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( !_States_Is_ready( the_thread->current_state ) ) {
   4869c:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   486a0:	6644           	bnes 486e6 <_Thread_Set_state+0x66>               	<== NOT EXECUTED
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = state;
   486a2:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED

  if ( _Chain_Has_only_one_node( ready ) ) {
   486a6:	2229 0008      	movel %a1@(8),%d1                                 	<== NOT EXECUTED
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = state;
   486aa:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED

  if ( _Chain_Has_only_one_node( ready ) ) {
   486ae:	b291           	cmpl %a1@,%d1                                     	<== NOT EXECUTED
   486b0:	6700 009a      	beqw 4874c <_Thread_Set_state+0xcc>               	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   486b4:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   486b6:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   486ba:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   486bc:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );
   486c0:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   486c6:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   486c8:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   486ca:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   486cc:	b5f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   486d2:	6730           	beqs 48704 <_Thread_Set_state+0x84>               	<== NOT EXECUTED
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   486d4:	b5f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   486da:	671c           	beqs 486f8 <_Thread_Set_state+0x78>               	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
   486dc:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   486de:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   486e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   486e4:	4e75           	rts                                               	<== NOT EXECUTED
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
  if ( !_States_Is_ready( the_thread->current_state ) ) {
    the_thread->current_state =
   486e6:	80ae 000c      	orl %fp@(12),%d0                                  	<== NOT EXECUTED
   486ea:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
   486ee:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
}
   486f0:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   486f4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   486f6:	4e75           	rts                                               	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = TRUE;
   486f8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   486fa:	13c1 0005 8822 	moveb %d1,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   48700:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   48702:	60da           	bras 486de <_Thread_Set_state+0x5e>               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
  Priority_Bit_map_control minor;
  Priority_Bit_map_control major;

  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
   48704:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4870a:	4840           	swap %d0                                          	<== NOT EXECUTED
   4870c:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   4870e:	41f9 0005 8878 	lea 58878 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   48714:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   4871a:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   4871e:	4841           	swap %d1                                          	<== NOT EXECUTED
   48720:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   48722:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   48724:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   4872a:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4872c:	2079 0005 8700 	moveal 58700 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   48732:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   48734:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   48736:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   48738:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   4873a:	d1c2           	addal %d2,%a0                                     	<== NOT EXECUTED
   4873c:	23d0 0005 87e2 	movel %a0@,587e2 <_Thread_Heir>                   	<== NOT EXECUTED
  _ISR_Flash( level );

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   48742:	b5f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   48748:	6692           	bnes 486dc <_Thread_Set_state+0x5c>               	<== NOT EXECUTED
   4874a:	60ac           	bras 486f8 <_Thread_Set_state+0x78>               	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Remove_from_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor &= the_priority_map->block_minor;
   4874c:	206a 0090      	moveal %a2@(144),%a0                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48750:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   48752:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   48754:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
   48756:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   48758:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   4875c:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4875e:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   48762:	3081           	movew %d1,%a0@                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   48764:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   48768:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   4876a:	6600 ff54      	bnew 486c0 <_Thread_Set_state+0x40>               	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   4876e:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   48774:	322a 0098      	movew %a2@(152),%d1                               	<== NOT EXECUTED
   48778:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4877a:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );
   48780:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   48786:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   48788:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4878a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   4878c:	b5f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   48792:	6600 ff40      	bnew 486d4 <_Thread_Set_state+0x54>               	<== NOT EXECUTED
   48796:	6000 ff6c      	braw 48704 <_Thread_Set_state+0x84>               	<== NOT EXECUTED
	...

0004879c <_Thread_Set_transient>:
 */

void _Thread_Set_transient(
  Thread_Control *the_thread
)
{
   4879c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   487a0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   487a2:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   487a6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level             level;
  uint32_t              old_state;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   487a8:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
{
  ISR_Level             level;
  uint32_t              old_state;
  Chain_Control *ready;

  ready = the_thread->ready;
   487ae:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   487b2:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   487b4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   487b6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  old_state = the_thread->current_state;
   487b8:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
  the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
   487bc:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   487be:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   487c0:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED

  if ( _States_Is_ready( old_state ) ) {
   487c4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   487c6:	6614           	bnes 487dc <_Thread_Set_transient+0x40>           	<== NOT EXECUTED
    if ( _Chain_Has_only_one_node( ready ) ) {
   487c8:	2029 0008      	movel %a1@(8),%d0                                 	<== NOT EXECUTED
   487cc:	b091           	cmpl %a1@,%d0                                     	<== NOT EXECUTED
   487ce:	6716           	beqs 487e6 <_Thread_Set_transient+0x4a>           	<== NOT EXECUTED
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
   487d0:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   487d4:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
   487d6:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   487d8:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED

    } else
      _Chain_Extract_unprotected( &the_thread->Object.Node );
  }

  _ISR_Enable( level );
   487dc:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

}
   487de:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   487e0:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   487e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   487e4:	4e75           	rts                                               	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Remove_from_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor &= the_priority_map->block_minor;
   487e6:	206a 0090      	moveal %a2@(144),%a0                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   487ea:	2209           	movel %a1,%d1                                     	<== NOT EXECUTED
   487ec:	5881           	addql #4,%d1                                      	<== NOT EXECUTED
   487ee:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
   487f0:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   487f2:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   487f6:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   487f8:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   487fc:	3081           	movew %d1,%a0@                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   487fe:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   48802:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   48804:	66d6           	bnes 487dc <_Thread_Set_transient+0x40>           	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   48806:	322a 0098      	movew %a2@(152),%d1                               	<== NOT EXECUTED
   4880a:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   48810:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   48812:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED

    } else
      _Chain_Extract_unprotected( &the_thread->Object.Node );
  }

  _ISR_Enable( level );
   48818:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

}
   4881a:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4881c:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4881e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48820:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048824 <_Thread_Stack_Allocate>:

size_t _Thread_Stack_Allocate(
  Thread_Control *the_thread,
  size_t          stack_size
)
{
   48824:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48828:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4882a:	2039 0005 6c3e 	movel 56c3e <rtems_minimum_stack_size>,%d0        	<== NOT EXECUTED
   48830:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   48834:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   48836:	6302           	blss 4883a <_Thread_Stack_Allocate+0x16>          	<== NOT EXECUTED
   48838:	2400           	movel %d0,%d2                                     	<== 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 ) {
   4883a:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   48840:	2068 0020      	moveal %a0@(32),%a0                               	<== NOT EXECUTED
   48844:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48846:	6720           	beqs 48868 <_Thread_Stack_Allocate+0x44>          	<== NOT EXECUTED
    stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
   48848:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4884a:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
  }

  if ( !stack_addr )
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   4884c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

    the_stack_size = _Stack_Adjust_size( the_stack_size );
    stack_addr = _Workspace_Allocate( the_stack_size );
  }

  if ( !stack_addr )
   48850:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   48852:	56c1           	sne %d1                                           	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   48854:	2140 00cc      	movel %d0,%a0@(204)                               	<== NOT EXECUTED

  return the_stack_size;
}
   48858:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4885a:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   * the RTEMS workspace allocate.  This is so the stack free
   * routine can call the correct deallocation routine.
   */

  if ( _Configuration_Table->stack_allocate_hook ) {
    stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
   4885e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    the_stack_size = _Stack_Adjust_size( the_stack_size );
    stack_addr = _Workspace_Allocate( the_stack_size );
  }

  if ( !stack_addr )
   48860:	49c1           	extbl %d1                                         	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;

  return the_stack_size;
}
   48862:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48864:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   48866:	4e75           	rts                                               	<== 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 );
   48868:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4886a:	4eb9 0004 9158 	jsr 49158 <_Workspace_Allocate>                   	<== NOT EXECUTED
  }

  if ( !stack_addr )
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   48870:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

    the_stack_size = _Stack_Adjust_size( the_stack_size );
    stack_addr = _Workspace_Allocate( the_stack_size );
  }

  if ( !stack_addr )
   48874:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   48876:	56c1           	sne %d1                                           	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   48878:	2140 00cc      	movel %d0,%a0@(204)                               	<== NOT EXECUTED

  return the_stack_size;
}
   4887c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4887e:	242e fffc      	movel %fp@(-4),%d2                                	<== 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 );
   48882:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  }

  if ( !stack_addr )
   48884:	49c1           	extbl %d1                                         	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;

  return the_stack_size;
}
   48886:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48888:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4888a:	4e75           	rts

0004888c <_Thread_Stack_Free>:
 */

void _Thread_Stack_Free(
  Thread_Control *the_thread
)
{
   4888c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48890:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48892:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
    /*
     *  If the API provided the stack space, then don't free it.
     */

    if ( !the_thread->Start.core_allocated_stack )
   48896:	4a2a 00be      	tstb %a2@(190)                                    	<== NOT EXECUTED
   4889a:	671a           	beqs 488b6 <_Thread_Stack_Free+0x2a>              	<== 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 )
   4889c:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   488a2:	2028 0024      	movel %a0@(36),%d0                                	<== NOT EXECUTED
   488a6:	6714           	beqs 488bc <_Thread_Stack_Free+0x30>              	<== NOT EXECUTED
      (*_Configuration_Table->stack_free_hook)(
   488a8:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   488aa:	2d6a 00c4 0008 	movel %a2@(196),%fp@(8)                           	<== NOT EXECUTED
        the_thread->Start.Initial_stack.area
      );
    else
        _Workspace_Free( the_thread->Start.Initial_stack.area );
}
   488b0:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   488b2:	4e5e           	unlk %fp                                          	<== 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)(
   488b4:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
        the_thread->Start.Initial_stack.area
      );
    else
        _Workspace_Free( the_thread->Start.Initial_stack.area );
}
   488b6:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   488b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   488ba:	4e75           	rts                                               	<== 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 );
   488bc:	2d6a 00c4 0008 	movel %a2@(196),%fp@(8)                           	<== NOT EXECUTED
}
   488c2:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   488c4:	4e5e           	unlk %fp                                          	<== 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 );
   488c6:	4ef9 0004 9140 	jmp 49140 <_Workspace_Free>                       	<== NOT EXECUTED

00048920 <_Thread_Start>:
  Thread_Start_types         the_prototype,
  void                      *entry_point,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   48920:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48924:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48926:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  if ( _States_Is_dormant( the_thread->current_state ) ) {
   4892a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4892c:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED
   48930:	6608           	bnes 4893a <_Thread_Start+0x1a>                   	<== NOT EXECUTED

    return true;
  }

  return false;
}
   48932:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48936:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48938:	4e75           	rts                                               	<== NOT EXECUTED

    the_thread->Start.prototype        = the_prototype;
    the_thread->Start.pointer_argument = pointer_argument;
    the_thread->Start.numeric_argument = numeric_argument;

    _Thread_Load_environment( the_thread );
   4893a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_Entry_numeric_type  numeric_argument
)
{
  if ( _States_Is_dormant( the_thread->current_state ) ) {

    the_thread->Start.entry_point      = (Thread_Entry) entry_point;
   4893c:	256e 0010 009c 	movel %fp@(16),%a2@(156)                          	<== NOT EXECUTED

    the_thread->Start.prototype        = the_prototype;
   48942:	256e 000c 00a0 	movel %fp@(12),%a2@(160)                          	<== NOT EXECUTED
    the_thread->Start.pointer_argument = pointer_argument;
   48948:	256e 0014 00a4 	movel %fp@(20),%a2@(164)                          	<== NOT EXECUTED
    the_thread->Start.numeric_argument = numeric_argument;
   4894e:	256e 0018 00a8 	movel %fp@(24),%a2@(168)                          	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );
   48954:	4eb9 0004 b700 	jsr 4b700 <_Thread_Load_environment>              	<== NOT EXECUTED

    _Thread_Ready( the_thread );
   4895a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4895c:	4eb9 0004 b9ec 	jsr 4b9ec <_Thread_Ready>                         	<== NOT EXECUTED

    _User_extensions_Thread_start( the_thread );
   48962:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48964:	4eb9 0004 8e50 	jsr 48e50 <_User_extensions_Thread_start>         	<== NOT EXECUTED

    return true;
  }

  return false;
}
   4896a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );

    _Thread_Ready( the_thread );

    _User_extensions_Thread_start( the_thread );
   4896e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

    return true;
  }

  return false;
}
   48974:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );

    _Thread_Ready( the_thread );

    _User_extensions_Thread_start( the_thread );
   48976:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

    return true;
  }

  return false;
}
   48978:	4e75           	rts                                               	<== NOT EXECUTED
	...

000488cc <_Thread_Start_multitasking>:
   488cc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;

  _Thread_Executing = _Thread_Heir;
   488ce:	2079 0005 87e2 	moveal 587e2 <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   488d4:	23c0 0005 88e6 	movel %d0,588e6 <_System_state_Current>           	<== NOT EXECUTED
   *  the system is shut down.
   */

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;
   488da:	4200           	clrb %d0                                          	<== NOT EXECUTED
 *    ready chain
 *    select heir
 */

void _Thread_Start_multitasking( void )
{
   488dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   *  the system is shut down.
   */

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;
   488e0:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _Thread_Executing = _Thread_Heir;
   488e6:	23c8 0005 8812 	movel %a0,58812 <_Thread_Executing>               	<== 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 )
   488ec:	4aa8 0104      	tstl %a0@(260)                                    	<== NOT EXECUTED
   488f0:	670c           	beqs 488fe <_Thread_Start_multitasking+0x32>      	<== NOT EXECUTED
     _Context_Restore_fp( &_Thread_Heir->fp_context );
   488f2:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   488f6:	4eb9 0004 9238 	jsr 49238 <_CPU_Context_restore_fp>               	<== NOT EXECUTED
   488fc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

  _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers );
   488fe:	2039 0005 87e2 	movel 587e2 <_Thread_Heir>,%d0                    	<== NOT EXECUTED
   48904:	0680 0000 00d0 	addil #208,%d0                                    	<== NOT EXECUTED
   4890a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4890c:	4879 0005 8720 	pea 58720 <_Thread_BSP_context>                   	<== NOT EXECUTED
   48912:	4eb9 0004 921c 	jsr 4921c <_CPU_Context_switch>                   	<== NOT EXECUTED
   48918:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   4891a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4891c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004897c <_Thread_Suspend>:
 */

void _Thread_Suspend(
  Thread_Control   *the_thread
)
{
   4897c:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   48980:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   48984:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   48988:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
)
{
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
   4898e:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   48992:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   48994:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48996:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  the_thread->suspend_count++;
   48998:	52aa 0070      	addql #1,%a2@(112)                                	<== NOT EXECUTED
  if ( !_States_Is_ready( the_thread->current_state ) ) {
   4899c:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   489a0:	6642           	bnes 489e4 <_Thread_Suspend+0x68>                 	<== NOT EXECUTED
    return;
  }

  the_thread->current_state = STATES_SUSPENDED;

  if ( _Chain_Has_only_one_node( ready ) ) {
   489a2:	2229 0008      	movel %a1@(8),%d1                                 	<== NOT EXECUTED
       _States_Set( STATES_SUSPENDED, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = STATES_SUSPENDED;
   489a6:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   489a8:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED

  if ( _Chain_Has_only_one_node( ready ) ) {
   489ac:	b291           	cmpl %a1@,%d1                                     	<== NOT EXECUTED
   489ae:	6700 009a      	beqw 48a4a <_Thread_Suspend+0xce>                 	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   489b2:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   489b4:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   489b8:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   489ba:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );
   489be:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   489c4:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   489c6:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   489c8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   489ca:	b5f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   489d0:	6730           	beqs 48a02 <_Thread_Suspend+0x86>                 	<== NOT EXECUTED
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   489d2:	b5f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   489d8:	671c           	beqs 489f6 <_Thread_Suspend+0x7a>                 	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
   489da:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   489dc:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   489e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   489e2:	4e75           	rts                                               	<== NOT EXECUTED

  ready = the_thread->ready;
  _ISR_Disable( level );
  the_thread->suspend_count++;
  if ( !_States_Is_ready( the_thread->current_state ) ) {
    the_thread->current_state =
   489e4:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   489e6:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   489e8:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED
       _States_Set( STATES_SUSPENDED, the_thread->current_state );
    _ISR_Enable( level );
   489ec:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
}
   489ee:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   489f2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   489f4:	4e75           	rts                                               	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = TRUE;
   489f6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   489f8:	13c1 0005 8822 	moveb %d1,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   489fe:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   48a00:	60da           	bras 489dc <_Thread_Suspend+0x60>                 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
  Priority_Bit_map_control minor;
  Priority_Bit_map_control major;

  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
   48a02:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   48a08:	4840           	swap %d0                                          	<== NOT EXECUTED
   48a0a:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   48a0c:	41f9 0005 8878 	lea 58878 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   48a12:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   48a18:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   48a1c:	4841           	swap %d1                                          	<== NOT EXECUTED
   48a1e:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
   48a20:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   48a22:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   48a28:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   48a2a:	2079 0005 8700 	moveal 58700 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   48a30:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   48a32:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   48a34:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   48a36:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   48a38:	d1c2           	addal %d2,%a0                                     	<== NOT EXECUTED
   48a3a:	23d0 0005 87e2 	movel %a0@,587e2 <_Thread_Heir>                   	<== NOT EXECUTED
  _ISR_Flash( level );

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   48a40:	b5f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   48a46:	6692           	bnes 489da <_Thread_Suspend+0x5e>                 	<== NOT EXECUTED
   48a48:	60ac           	bras 489f6 <_Thread_Suspend+0x7a>                 	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Remove_from_bit_map (
  Priority_Information *the_priority_map
)
{
  *the_priority_map->minor &= the_priority_map->block_minor;
   48a4a:	206a 0090      	moveal %a2@(144),%a0                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48a4e:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   48a50:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   48a52:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
   48a54:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   48a56:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   48a5a:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   48a5c:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   48a60:	3081           	movew %d1,%a0@                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   48a62:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   48a66:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   48a68:	6600 ff54      	bnew 489be <_Thread_Suspend+0x42>                 	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   48a6c:	3039 0005 8808 	movew 58808 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   48a72:	322a 0098      	movew %a2@(152),%d1                               	<== NOT EXECUTED
   48a76:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   48a78:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );
   48a7e:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   48a84:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   48a86:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48a88:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   48a8a:	b5f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   48a90:	6600 ff40      	bnew 489d2 <_Thread_Suspend+0x56>                 	<== NOT EXECUTED
   48a94:	6000 ff6c      	braw 48a02 <_Thread_Suspend+0x86>                 	<== NOT EXECUTED

00048a98 <_Thread_Tickle_timeslice>:
 *
 *  Output parameters:  NONE
 */

void _Thread_Tickle_timeslice( void )
{
   48a98:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48a9c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_Control *executing;

  executing = _Thread_Executing;
   48a9e:	2479 0005 8812 	moveal 58812 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  /*
   *  If the thread is not preemptible or is not ready, then
   *  just return.
   */

  if ( !executing->is_preemptible )
   48aa4:	4a2a 0076      	tstb %a2@(118)                                    	<== NOT EXECUTED
   48aa8:	6720           	beqs 48aca <_Thread_Tickle_timeslice+0x32>        	<== NOT EXECUTED
    return;

  if ( !_States_Is_ready( executing->current_state ) )
   48aaa:	4aaa 0010      	tstl %a2@(16)                                     	<== NOT EXECUTED
   48aae:	661a           	bnes 48aca <_Thread_Tickle_timeslice+0x32>        	<== NOT EXECUTED

  /*
   *  The cpu budget algorithm determines what happens next.
   */

  switch ( executing->budget_algorithm ) {
   48ab0:	202a 007c      	movel %a2@(124),%d0                               	<== NOT EXECUTED
   48ab4:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   48ab6:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   48ab8:	6210           	bhis 48aca <_Thread_Tickle_timeslice+0x32>        	<== NOT EXECUTED
   48aba:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   48abe:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   48ac0:	642e           	bccs 48af0 <_Thread_Tickle_timeslice+0x58>        	<== NOT EXECUTED
   48ac2:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   48ac6:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   48ac8:	6708           	beqs 48ad2 <_Thread_Tickle_timeslice+0x3a>        	<== NOT EXECUTED
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      if ( --executing->cpu_time_budget == 0 )
        (*executing->budget_callout)( executing );
      break;
  }
}
   48aca:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48ace:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48ad0:	4e75           	rts                                               	<== NOT EXECUTED
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
      }
      break;

    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      if ( --executing->cpu_time_budget == 0 )
   48ad2:	202a 0078      	movel %a2@(120),%d0                               	<== NOT EXECUTED
   48ad6:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   48ad8:	2540 0078      	movel %d0,%a2@(120)                               	<== NOT EXECUTED
   48adc:	66ec           	bnes 48aca <_Thread_Tickle_timeslice+0x32>        	<== NOT EXECUTED
        (*executing->budget_callout)( executing );
   48ade:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48ae0:	206a 0080      	moveal %a2@(128),%a0                              	<== NOT EXECUTED
   48ae4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
      break;
  }
}
   48ae6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
      }
      break;

    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      if ( --executing->cpu_time_budget == 0 )
        (*executing->budget_callout)( executing );
   48aea:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      break;
  }
}
   48aec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48aee:	4e75           	rts                                               	<== 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 ) {
   48af0:	202a 0078      	movel %a2@(120),%d0                               	<== NOT EXECUTED
   48af4:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   48af6:	2540 0078      	movel %d0,%a2@(120)                               	<== NOT EXECUTED
   48afa:	6ece           	bgts 48aca <_Thread_Tickle_timeslice+0x32>        	<== NOT EXECUTED
        _Thread_Reset_timeslice();
   48afc:	4eb9 0004 baac 	jsr 4baac <_Thread_Reset_timeslice>               	<== NOT EXECUTED
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
   48b02:	41f9 0005 8704 	lea 58704 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   48b08:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      if ( --executing->cpu_time_budget == 0 )
        (*executing->budget_callout)( executing );
      break;
  }
}
   48b0c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48b10:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48b12:	4e75           	rts

00048b14 <_Thread_Yield_processor>:
 *    ready chain
 *    select heir
 */

void _Thread_Yield_processor( void )
{
   48b14:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   48b18:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
   48b1c:	2679 0005 8812 	moveal 58812 <_Thread_Executing>,%a3              	<== NOT EXECUTED
  ready     = executing->ready;
  _ISR_Disable( level );
   48b22:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
  ready     = executing->ready;
   48b28:	286b 008c      	moveal %a3@(140),%a4                              	<== NOT EXECUTED
  _ISR_Disable( level );
   48b2c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   48b2e:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   48b30:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   48b32:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_Chain_Has_only_one_node( ready ) ) {
   48b34:	202c 0008      	movel %a4@(8),%d0                                 	<== NOT EXECUTED
   48b38:	b094           	cmpl %a4@,%d0                                     	<== NOT EXECUTED
   48b3a:	6752           	beqs 48b8e <_Thread_Yield_processor+0x7a>         	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   48b3c:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   48b3e:	226b 0004      	moveal %a3@(4),%a1                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   48b42:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   48b44:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   48b46:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   48b48:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   48b4a:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
   48b4e:	246c 0008      	moveal %a4@(8),%a2                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   48b52:	294b 0008      	movel %a3,%a4@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   48b56:	274a 0004      	movel %a2,%a3@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   48b5a:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED
      _Chain_Extract_unprotected( &executing->Object.Node );
      _Chain_Append_unprotected( ready, &executing->Object.Node );

      _ISR_Flash( level );
   48b5c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   48b5e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   48b60:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   48b62:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      if ( _Thread_Is_heir( executing ) )
   48b64:	b7f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a3                    	<== NOT EXECUTED
   48b6a:	6712           	beqs 48b7e <_Thread_Yield_processor+0x6a>         	<== NOT EXECUTED
        _Thread_Heir = (Thread_Control *) ready->first;
      _Context_Switch_necessary = TRUE;
    }
    else if ( !_Thread_Is_heir( executing ) )
      _Context_Switch_necessary = TRUE;
   48b6c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   48b6e:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   48b74:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   48b76:	4cd7 1c04      	moveml %sp@,%d2/%a2-%a4                           	<== NOT EXECUTED
   48b7a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48b7c:	4e75           	rts                                               	<== NOT EXECUTED
      _Chain_Append_unprotected( ready, &executing->Object.Node );

      _ISR_Flash( level );

      if ( _Thread_Is_heir( executing ) )
        _Thread_Heir = (Thread_Control *) ready->first;
   48b7e:	23d4 0005 87e2 	movel %a4@,587e2 <_Thread_Heir>                   	<== NOT EXECUTED
      _Context_Switch_necessary = TRUE;
    }
    else if ( !_Thread_Is_heir( executing ) )
      _Context_Switch_necessary = TRUE;
   48b84:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   48b86:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
   48b8c:	60e6           	bras 48b74 <_Thread_Yield_processor+0x60>         	<== NOT EXECUTED

      if ( _Thread_Is_heir( executing ) )
        _Thread_Heir = (Thread_Control *) ready->first;
      _Context_Switch_necessary = TRUE;
    }
    else if ( !_Thread_Is_heir( executing ) )
   48b8e:	b7f9 0005 87e2 	cmpal 587e2 <_Thread_Heir>,%a3                    	<== NOT EXECUTED
   48b94:	67de           	beqs 48b74 <_Thread_Yield_processor+0x60>         	<== NOT EXECUTED
      _Context_Switch_necessary = TRUE;
   48b96:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   48b98:	13c0 0005 8822 	moveb %d0,58822 <_Context_Switch_necessary>       	<== NOT EXECUTED
   48b9e:	60d4           	bras 48b74 <_Thread_Yield_processor+0x60>         	<== NOT EXECUTED

0004772c <_Thread_blocking_operation_Cancel>:
void _Thread_blocking_operation_Cancel(
  Thread_blocking_operation_States  sync_state,
  Thread_Control                   *the_thread,
  ISR_Level                         level
)
{
   4772c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47730:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47732:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   47736:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
  #endif

  /*
   * The thread is not waiting on anything after this completes.
   */
  the_thread->Wait.queue = NULL;
   4773a:	42aa 0044      	clrl %a2@(68)                                     	<== 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 ) ) {
   4773e:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   47740:	b2aa 0050      	cmpl %a2@(80),%d1                                 	<== NOT EXECUTED
   47744:	671c           	beqs 47762 <_Thread_blocking_operation_Cancel+0x36>	<== NOT EXECUTED
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
    (void) _Watchdog_Remove( &the_thread->Timer );
  } else
    _ISR_Enable( level );
   47746:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   47748:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4774c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47750:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
   47756:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4775a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4775c:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   47762:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   47766:	2541 0050      	movel %d1,%a2@(80)                                	<== NOT EXECUTED
   *  If the sync state is timed out, this is very likely not needed.
   *  But better safe than sorry when it comes to critical sections.
   */
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4776a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4776c:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   47770:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   47776:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4777a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4777e:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
   *  But better safe than sorry when it comes to critical sections.
   */
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
    (void) _Watchdog_Remove( &the_thread->Timer );
   47784:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47786:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4778a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4778c:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
	...

000480b8 <_Thread_queue_Dequeue>:
 */

Thread_Control *_Thread_queue_Dequeue(
  Thread_queue_Control *the_thread_queue
)
{
   480b8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   480bc:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   480c0:	246e 0008      	moveal %fp@(8),%a2                                	<== 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 )
   480c4:	41f9 0004 8124 	lea 48124 <_Thread_queue_Dequeue_priority>,%a0    	<== NOT EXECUTED
   480ca:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   480cc:	b0aa 0034      	cmpl %a2@(52),%d0                                 	<== NOT EXECUTED
   480d0:	6706           	beqs 480d8 <_Thread_queue_Dequeue+0x20>           	<== NOT EXECUTED
   480d2:	41f9 0004 b784 	lea 4b784 <_Thread_queue_Dequeue_fifo>,%a0        	<== 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 );
   480d8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   480da:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   480dc:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  _ISR_Disable( level );
   480de:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   480e4:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   480e6:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   480e8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !the_thread ) {
   480ea:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   480ec:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   480ee:	670e           	beqs 480fe <_Thread_queue_Dequeue+0x46>           	<== NOT EXECUTED
           (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
        the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
        the_thread = _Thread_Executing;
      }
    }
  _ISR_Enable( level );
   480f0:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return the_thread;
}
   480f2:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   480f8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   480fa:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   480fc:	4e75           	rts                                               	<== NOT EXECUTED

  the_thread = (*dequeue_p)( the_thread_queue );
  _ISR_Disable( level );
    if ( !the_thread ) {
      sync_state = the_thread_queue->sync_state;
      if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
   480fe:	202a 0030      	movel %a2@(48),%d0                                	<== NOT EXECUTED
   48102:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   48104:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   48106:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   48108:	65e6           	bcss 480f0 <_Thread_queue_Dequeue+0x38>           	<== NOT EXECUTED
           (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
        the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
   4810a:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
        the_thread = _Thread_Executing;
   4810c:	2239 0005 8812 	movel 58812 <_Thread_Executing>,%d1               	<== NOT EXECUTED
  _ISR_Disable( level );
    if ( !the_thread ) {
      sync_state = the_thread_queue->sync_state;
      if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
           (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
        the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
   48112:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
        the_thread = _Thread_Executing;
      }
    }
  _ISR_Enable( level );
   48116:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return the_thread;
}
   48118:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   4811e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48120:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   48122:	4e75           	rts

0004b784 <_Thread_queue_Dequeue_fifo>:
 */

Thread_Control *_Thread_queue_Dequeue_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   4b784:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b788:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *the_thread;

  _ISR_Disable( level );
   4b78a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Thread_Control *_Thread_queue_Dequeue_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   4b790:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b792:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *the_thread;

  _ISR_Disable( level );
   4b796:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4b798:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4b79a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   4b79c:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   4b79e:	2458           	moveal %a0@+,%a2                                  	<== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
   4b7a0:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   4b7a2:	676a           	beqs 4b80e <_Thread_queue_Dequeue_fifo+0x8a>      	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   4b7a4:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   4b7a6:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED

    the_thread = (Thread_Control *)
   4b7a8:	264a           	moveal %a2,%a3                                    	<== NOT EXECUTED
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );

    the_thread->Wait.queue = NULL;
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4b7aa:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   4b7ac:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {

    the_thread = (Thread_Control *)
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );

    the_thread->Wait.queue = NULL;
   4b7b0:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4b7b4:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4b7b8:	6720           	beqs 4b7da <_Thread_queue_Dequeue_fifo+0x56>      	<== NOT EXECUTED
      _ISR_Enable( level );
   4b7ba:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   4b7bc:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   4b7c2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b7c4:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
    return the_thread;
  }

  _ISR_Enable( level );
  return NULL;
}
   4b7ca:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   4b7cc:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4b7d0:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4b7d4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4b7d6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b7d8:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   4b7da:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4b7dc:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
      _ISR_Enable( level );
      _Thread_Unblock( the_thread );
    } else {
      _Watchdog_Deactivate( &the_thread->Timer );
      _ISR_Enable( level );
   4b7e0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );
   4b7e2:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4b7e6:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   4b7ec:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   4b7f2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b7f4:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
    return the_thread;
  }

  _ISR_Enable( level );
  return NULL;
}
   4b7fa:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   4b7fc:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4b800:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4b804:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4b80a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b80c:	4e75           	rts                                               	<== NOT EXECUTED
#endif

    return the_thread;
  }

  _ISR_Enable( level );
   4b80e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4b810:	97cb           	subal %a3,%a3                                     	<== NOT EXECUTED
  return NULL;
}
   4b812:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   4b814:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4b818:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4b81c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b81e:	4e75           	rts

00048124 <_Thread_queue_Dequeue_priority>:
 */

Thread_Control *_Thread_queue_Dequeue_priority(
  Thread_queue_Control *the_thread_queue
)
{
   48124:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   48128:	48d7 3c00      	moveml %a2-%a5,%sp@                               	<== NOT EXECUTED
  Chain_Node     *new_second_node;
  Chain_Node     *last_node;
  Chain_Node     *next_node;
  Chain_Node     *previous_node;

  _ISR_Disable( level );
   4812c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Thread_Control *_Thread_queue_Dequeue_priority(
  Thread_queue_Control *the_thread_queue
)
{
   48132:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
  Chain_Node     *new_second_node;
  Chain_Node     *last_node;
  Chain_Node     *next_node;
  Chain_Node     *previous_node;

  _ISR_Disable( level );
   48136:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   48138:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4813a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4813c:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   4813e:	244c           	moveal %a4,%a2                                    	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   48140:	2652           	moveal %a2@,%a3                                   	<== NOT EXECUTED
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
       index++ ) {
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
   48142:	41f1 9a01      	lea %a1@(00000001,%a1:l:2),%a0                    	<== NOT EXECUTED
  Chain_Node     *previous_node;

  _ISR_Disable( level );
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
       index++ ) {
   48146:	d5fc 0000 000c 	addal #12,%a2                                     	<== NOT EXECUTED
   4814c:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
   4814e:	41f4 8c00      	lea %a4@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   48152:	b1cb           	cmpal %a3,%a0                                     	<== NOT EXECUTED
   48154:	6616           	bnes 4816c <_Thread_queue_Dequeue_priority+0x48>  	<== NOT EXECUTED
  Chain_Node     *next_node;
  Chain_Node     *previous_node;

  _ISR_Disable( level );
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
   48156:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   48158:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   4815a:	66e4           	bnes 48140 <_Thread_queue_Dequeue_priority+0x1c>  	<== NOT EXECUTED
  }

  /*
   * We did not find a thread to unblock.
   */
  _ISR_Enable( level );
   4815c:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4815e:	99cc           	subal %a4,%a4                                     	<== 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 );
}
   48160:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   48162:	4cee 3c00 fff0 	moveml %fp@(-16),%a2-%a5                          	<== NOT EXECUTED
   48168:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4816a:	4e75           	rts                                               	<== NOT EXECUTED
  _ISR_Enable( level );
  return NULL;

dequeue:
  the_thread->Wait.queue = NULL;
  new_first_node   = the_thread->Wait.Block2n.first;
   4816c:	206b 0038      	moveal %a3@(56),%a0                               	<== NOT EXECUTED
  new_first_thread = (Thread_Control *) new_first_node;
  next_node        = the_thread->Object.Node.next;
   48170:	2453           	moveal %a3@,%a2                                   	<== NOT EXECUTED
  previous_node    = the_thread->Object.Node.previous;
   48172:	226b 0004      	moveal %a3@(4),%a1                                	<== NOT EXECUTED

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
   48176:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   */
  _ISR_Enable( level );
  return NULL;

dequeue:
  the_thread->Wait.queue = NULL;
   48178:	42ab 0044      	clrl %a3@(68)                                     	<== NOT EXECUTED
  _ISR_Disable( level );
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
       index++ ) {
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
      the_thread = (Thread_Control *)
   4817c:	284b           	moveal %a3,%a4                                    	<== NOT EXECUTED
  new_first_node   = the_thread->Wait.Block2n.first;
  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 ) ) {
   4817e:	0680 0000 003c 	addil #60,%d0                                     	<== NOT EXECUTED
   48184:	b088           	cmpl %a0,%d0                                      	<== NOT EXECUTED
   48186:	6700 0090      	beqw 48218 <_Thread_queue_Dequeue_priority+0xf4>  	<== NOT EXECUTED
    last_node       = the_thread->Wait.Block2n.last;
   4818a:	202b 0040      	movel %a3@(64),%d0                                	<== NOT EXECUTED
    new_second_node = new_first_node->next;
   4818e:	2a50           	moveal %a0@,%a5                                   	<== NOT EXECUTED

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
   48190:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
    last_node       = the_thread->Wait.Block2n.last;
    new_second_node = new_first_node->next;

    previous_node->next      = new_first_node;
   48194:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
    new_first_node->previous = previous_node;
   48196:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
    last_node       = the_thread->Wait.Block2n.last;
    new_second_node = new_first_node->next;

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
   4819a:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
    new_first_node->previous = previous_node;

    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
   4819c:	226b 0040      	moveal %a3@(64),%a1                               	<== NOT EXECUTED
   481a0:	b3eb 0038      	cmpal %a3@(56),%a1                                	<== NOT EXECUTED
   481a4:	671a           	beqs 481c0 <_Thread_queue_Dequeue_priority+0x9c>  	<== NOT EXECUTED
                                                /* > two threads on 2-n */
      new_second_node->previous =
   481a6:	43e8 0038      	lea %a0@(56),%a1                                  	<== NOT EXECUTED
   481aa:	2b49 0004      	movel %a1,%a5@(4)                                 	<== NOT EXECUTED
                _Chain_Head( &new_first_thread->Wait.Block2n );

      new_first_thread->Wait.Block2n.first = new_second_node;
      new_first_thread->Wait.Block2n.last  = last_node;

      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
   481ae:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
                                                /* > two threads on 2-n */
      new_second_node->previous =
                _Chain_Head( &new_first_thread->Wait.Block2n );

      new_first_thread->Wait.Block2n.first = new_second_node;
   481b0:	214d 0038      	movel %a5,%a0@(56)                                	<== NOT EXECUTED
      new_first_thread->Wait.Block2n.last  = last_node;
   481b4:	2140 0040      	movel %d0,%a0@(64)                                	<== NOT EXECUTED

      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
   481b8:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
   481be:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  } else {
    previous_node->next = next_node;
    next_node->previous = previous_node;
  }

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   481c0:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   481c2:	b0ab 0050      	cmpl %a3@(80),%d0                                 	<== NOT EXECUTED
   481c6:	671e           	beqs 481e6 <_Thread_queue_Dequeue_priority+0xc2>  	<== NOT EXECUTED
    _ISR_Enable( level );
   481c8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   481ca:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   481d0:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   481d2:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== 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 );
}
   481d8:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   481da:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   481dc:	4cee 3c00 fff0 	moveml %fp@(-16),%a2-%a5                          	<== NOT EXECUTED
   481e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   481e4:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   481e6:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   481e8:	2740 0050      	movel %d0,%a3@(80)                                	<== NOT EXECUTED
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
    _ISR_Enable( level );
    _Thread_Unblock( the_thread );
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   481ec:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   481ee:	486b 0048      	pea %a3@(72)                                      	<== NOT EXECUTED
   481f2:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   481f8:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   481fe:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   48200:	4eb9 0004 78e4 	jsr 478e4 <_Thread_Clear_state>                   	<== 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 );
}
   48206:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   48208:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4820e:	4cee 3c00 fff0 	moveml %fp@(-16),%a2-%a5                          	<== NOT EXECUTED
   48214:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48216:	4e75           	rts                                               	<== NOT EXECUTED

      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
    }
  } else {
    previous_node->next = next_node;
    next_node->previous = previous_node;
   48218:	2549 0004      	movel %a1,%a2@(4)                                 	<== NOT EXECUTED
      new_first_thread->Wait.Block2n.last  = last_node;

      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
    }
  } else {
    previous_node->next = next_node;
   4821c:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
   4821e:	60a0           	bras 481c0 <_Thread_queue_Dequeue_priority+0x9c>  	<== NOT EXECUTED

0004b820 <_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
)
{
   4b820:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b824:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_blocking_operation_States sync_state;
  ISR_Level                        level;

  _ISR_Disable( level );
   4b826:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
Thread_blocking_operation_States _Thread_queue_Enqueue_fifo (
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_Level            *level_p
)
{
   4b82c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4b82e:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4b832:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Thread_blocking_operation_States sync_state;
  ISR_Level                        level;

  _ISR_Disable( level );
   4b836:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4b838:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4b83a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    sync_state = the_thread_queue->sync_state;
   4b83c:	2029 0030      	movel %a1@(48),%d0                                	<== NOT EXECUTED
    the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
   4b840:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
  ISR_Level                        level;

  _ISR_Disable( level );

    sync_state = the_thread_queue->sync_state;
    the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   4b842:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
   4b846:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   4b848:	670e           	beqs 4b858 <_Thread_queue_Enqueue_fifo+0x38>      	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return sync_state;
}
   4b84a:	241f           	movel %sp@+,%d2                                   	<== 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;
   4b84c:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  return sync_state;
}
   4b850:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4b852:	4e5e           	unlk %fp                                          	<== 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;
   4b854:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  return sync_state;
}
   4b856:	4e75           	rts                                               	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4b858:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   4b85a:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   4b85c:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   4b85e:	2069 0008      	moveal %a1@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   4b862:	234a 0008      	movel %a2,%a1@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4b866:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
      _Chain_Append_unprotected(
        &the_thread_queue->Queues.Fifo,
        &the_thread->Object.Node
      );
      the_thread->Wait.queue = the_thread_queue;
   4b86a:	2549 0044      	movel %a1,%a2@(68)                                	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   4b86e:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED

      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
      _ISR_Enable( level );
   4b870:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return sync_state;
}
   4b872:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4b874:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4b876:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b878:	4e75           	rts                                               	<== NOT EXECUTED
	...

000482c4 <_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
)
{
   482c4:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   482c8:	48d7 1c7c      	moveml %d2-%d6/%a2-%a4,%sp@                       	<== NOT EXECUTED
   482cc:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   482d0:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  Priority_Control     priority;
  States_Control       block_state;

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
   482d4:	242a 0014      	movel %a2@(20),%d2                                	<== NOT EXECUTED
  header_index = _Thread_queue_Header_number( priority );
  header       = &the_thread_queue->Queues.Priority[ header_index ];
  block_state  = the_thread_queue->state;
   482d8:	282b 0038      	movel %a3@(56),%d4                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   482dc:	41ea 003c      	lea %a2@(60),%a0                                  	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   482e0:	43ea 0038      	lea %a2@(56),%a1                                  	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE uint32_t   _Thread_queue_Header_number (
  Priority_Control the_priority
)
{
  return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
   482e4:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   482e6:	2548 0038      	movel %a0,%a2@(56)                                	<== NOT EXECUTED
   482ea:	ec89           	lsrl #6,%d1                                       	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   482ec:	2549 0040      	movel %a1,%a2@(64)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   482f0:	42aa 003c      	clrl %a2@(60)                                     	<== NOT EXECUTED

  if ( _Thread_queue_Is_reverse_search( priority ) )
   482f4:	0802 0005      	btst #5,%d2                                       	<== NOT EXECUTED
   482f8:	6666           	bnes 48360 <_Thread_queue_Enqueue_priority+0x9c>  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   482fa:	2241           	moveal %d1,%a1                                    	<== NOT EXECUTED
   482fc:	41f1 1a01      	lea %a1@(00000001,%d1:l:2),%a0                    	<== NOT EXECUTED
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
   48300:	2a3c 0000 0700 	movel #1792,%d5                                   	<== NOT EXECUTED
   48306:	7c0c           	moveq #12,%d6                                     	<== NOT EXECUTED
   48308:	4c01 6800      	mulsl %d1,%d6                                     	<== NOT EXECUTED
   4830c:	41f3 8c00      	lea %a3@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   48310:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48312:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   48314:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48316:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->first;
   48318:	2273 6800      	moveal %a3@(00000000,%d6:l),%a1                   	<== NOT EXECUTED
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
   4831c:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   4831e:	6700 0144      	beqw 48464 <_Thread_queue_Enqueue_priority+0x1a0> 	<== NOT EXECUTED
    search_priority = search_thread->current_priority;
   48322:	2229 0014      	movel %a1@(20),%d1                                	<== NOT EXECUTED
    if ( priority <= search_priority )
   48326:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   48328:	6418           	bccs 48342 <_Thread_queue_Enqueue_priority+0x7e>  	<== NOT EXECUTED
      break;
    search_priority = search_thread->current_priority;
    if ( priority <= search_priority )
      break;
#endif
    _ISR_Flash( level );
   4832a:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4832c:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   4832e:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48330:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   48332:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   48334:	c0a9 0010      	andl %a1@(16),%d0                                 	<== NOT EXECUTED
   48338:	6700 00c4      	beqw 483fe <_Thread_queue_Enqueue_priority+0x13a> 	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_forward_search;
    }
    search_thread =
   4833c:	2251           	moveal %a1@,%a1                                   	<== 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 ) ) {
   4833e:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   48340:	66e0           	bnes 48322 <_Thread_queue_Enqueue_priority+0x5e>  	<== NOT EXECUTED
   48342:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
   48344:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   48346:	b8ab 0030      	cmpl %a3@(48),%d4                                 	<== NOT EXECUTED
   4834a:	6700 00c8      	beqw 48414 <_Thread_queue_Enqueue_priority+0x150> 	<== 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;
   4834e:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  return the_thread_queue->sync_state;
   48352:	202b 0030      	movel %a3@(48),%d0                                	<== 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;
   48356:	2083           	movel %d3,%a0@                                    	<== NOT EXECUTED
  return the_thread_queue->sync_state;
}
   48358:	4cd7 1c7c      	moveml %sp@,%d2-%d6/%a2-%a4                       	<== NOT EXECUTED
   4835c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4835e:	4e75           	rts                                               	<== NOT EXECUTED
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   48360:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   48362:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   48364:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   48366:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   48368:	41f3 0800      	lea %a3@(00000000,%d0:l),%a0                      	<== NOT EXECUTED

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;
   4836c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4836e:	1039 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED

  _ISR_Disable( level );
   48374:	2a3c 0000 0700 	movel #1792,%d5                                   	<== 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;
   4837a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED

  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->last;
   4837c:	49e8 0008      	lea %a0@(8),%a4                                   	<== 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;
   48380:	5281           	addql #1,%d1                                      	<== NOT EXECUTED

  _ISR_Disable( level );
   48382:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48384:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   48386:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48388:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->last;
   4838a:	2254           	moveal %a4@,%a1                                   	<== NOT EXECUTED
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
   4838c:	b3c8           	cmpal %a0,%a1                                     	<== NOT EXECUTED
   4838e:	6720           	beqs 483b0 <_Thread_queue_Enqueue_priority+0xec>  	<== NOT EXECUTED
    search_priority = search_thread->current_priority;
   48390:	2229 0014      	movel %a1@(20),%d1                                	<== NOT EXECUTED
    if ( priority >= search_priority )
   48394:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   48396:	6318           	blss 483b0 <_Thread_queue_Enqueue_priority+0xec>  	<== NOT EXECUTED
      break;
    search_priority = search_thread->current_priority;
    if ( priority >= search_priority )
      break;
#endif
    _ISR_Flash( level );
   48398:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4839a:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   4839c:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4839e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   483a0:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   483a2:	c0a9 0010      	andl %a1@(16),%d0                                 	<== NOT EXECUTED
   483a6:	6738           	beqs 483e0 <_Thread_queue_Enqueue_priority+0x11c> 	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_reverse_search;
    }
    search_thread = (Thread_Control *)
   483a8:	2269 0004      	moveal %a1@(4),%a1                                	<== 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 ) ) {
   483ac:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   483ae:	66e0           	bnes 48390 <_Thread_queue_Enqueue_priority+0xcc>  	<== NOT EXECUTED
   483b0:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
   483b2:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   483b4:	b8ab 0030      	cmpl %a3@(48),%d4                                 	<== NOT EXECUTED
   483b8:	6694           	bnes 4834e <_Thread_queue_Enqueue_priority+0x8a>  	<== NOT EXECUTED
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   483ba:	42ab 0030      	clrl %a3@(48)                                     	<== NOT EXECUTED

  if ( priority == search_priority )
   483be:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   483c0:	677a           	beqs 4843c <_Thread_queue_Enqueue_priority+0x178> 	<== NOT EXECUTED
    goto equal_priority;

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
   483c2:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
  the_node->previous      = search_node;
   483c4:	2549 0004      	movel %a1,%a2@(4)                                 	<== NOT EXECUTED

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
   483c8:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  the_node->previous      = search_node;
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
   483ca:	254b 0044      	movel %a3,%a2@(68)                                	<== NOT EXECUTED
  next_node   = search_node->next;
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
  the_node->previous      = search_node;
  search_node->next       = the_node;
   483ce:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
  next_node->previous    = the_node;
   483d0:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   483d4:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   483d6:	4cd7 1c7c      	moveml %sp@,%d2-%d6/%a2-%a4                       	<== NOT EXECUTED
   483da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_node->next          = next_node;
  the_node->previous      = search_node;
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   483dc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   483de:	4e75           	rts                                               	<== NOT EXECUTED
    if ( priority >= search_priority )
      break;
#endif
    _ISR_Flash( level );
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
      _ISR_Enable( level );
   483e0:	46c3           	movew %d3,%sr                                     	<== 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;
   483e2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   483e4:	1039 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   483ea:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   483ec:	5281           	addql #1,%d1                                      	<== NOT EXECUTED

  _ISR_Disable( level );
   483ee:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   483f0:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   483f2:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   483f4:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->last;
   483f6:	2254           	moveal %a4@,%a1                                   	<== NOT EXECUTED
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
   483f8:	b3c8           	cmpal %a0,%a1                                     	<== NOT EXECUTED
   483fa:	6694           	bnes 48390 <_Thread_queue_Enqueue_priority+0xcc>  	<== NOT EXECUTED
   483fc:	60b2           	bras 483b0 <_Thread_queue_Enqueue_priority+0xec>  	<== NOT EXECUTED
    if ( priority <= search_priority )
      break;
#endif
    _ISR_Flash( level );
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
      _ISR_Enable( level );
   483fe:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
  if ( _Thread_queue_Is_reverse_search( priority ) )
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
   48400:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48402:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   48404:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   48406:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->first;
   48408:	2273 6800      	moveal %a3@(00000000,%d6:l),%a1                   	<== NOT EXECUTED
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
   4840c:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   4840e:	6600 ff12      	bnew 48322 <_Thread_queue_Enqueue_priority+0x5e>  	<== NOT EXECUTED
   48412:	6050           	bras 48464 <_Thread_queue_Enqueue_priority+0x1a0> 	<== NOT EXECUTED

  if ( the_thread_queue->sync_state !=
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   48414:	42ab 0030      	clrl %a3@(48)                                     	<== NOT EXECUTED

  if ( priority == search_priority )
   48418:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   4841a:	6720           	beqs 4843c <_Thread_queue_Enqueue_priority+0x178> 	<== NOT EXECUTED
    goto equal_priority;

  search_node   = (Chain_Node *) search_thread;
  previous_node = search_node->previous;
   4841c:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   48420:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
  the_node->previous     = previous_node;
   48422:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
   48426:	254b 0044      	movel %a3,%a2@(68)                                	<== NOT EXECUTED
  previous_node = search_node->previous;
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
   4842a:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
  search_node->previous  = the_node;
   4842c:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   48430:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   48432:	4cd7 1c7c      	moveml %sp@,%d2-%d6/%a2-%a4                       	<== NOT EXECUTED
   48436:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_node->next         = search_node;
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   48438:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   4843a:	4e75           	rts                                               	<== NOT EXECUTED
   4843c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4843e:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

equal_priority:               /* add at end of priority group */
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );
  previous_node = search_node->previous;
   48444:	2268 0004      	moveal %a0@(4),%a1                                	<== NOT EXECUTED
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   48448:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  the_node->previous     = previous_node;
   4844a:	2549 0004      	movel %a1,%a2@(4)                                 	<== NOT EXECUTED
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
   4844e:	254b 0044      	movel %a3,%a2@(68)                                	<== NOT EXECUTED
  previous_node = search_node->previous;
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
   48452:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
  search_node->previous  = the_node;
   48454:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   48458:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   4845a:	4cd7 1c7c      	moveml %sp@,%d2-%d6/%a2-%a4                       	<== NOT EXECUTED
   4845e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_node->next         = search_node;
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   48460:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
}
   48462:	4e75           	rts                                               	<== 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 ) ) {
   48464:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   48466:	72ff           	moveq #-1,%d1                                     	<== NOT EXECUTED
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
   48468:	7801           	moveq #1,%d4                                      	<== NOT EXECUTED
   4846a:	b8ab 0030      	cmpl %a3@(48),%d4                                 	<== NOT EXECUTED
   4846e:	6600 fede      	bnew 4834e <_Thread_queue_Enqueue_priority+0x8a>  	<== NOT EXECUTED
   48472:	60a0           	bras 48414 <_Thread_queue_Enqueue_priority+0x150> 	<== NOT EXECUTED

00048220 <_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
)
{
   48220:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   48224:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   48226:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4822a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
    Thread_queue_Control *,
    Thread_Control *,
    ISR_Level *
  );

  the_thread = _Thread_Executing;
   4822c:	2479 0005 8812 	moveal 58812 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  else
#endif
  /*
   *  Set the blocking state for this thread queue in the thread.
   */
  _Thread_Set_state( the_thread, the_thread_queue->state );
   48232:	2f2b 0038      	movel %a3@(56),%sp@-                              	<== NOT EXECUTED
   48236:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48238:	4eb9 0004 8680 	jsr 48680 <_Thread_Set_state>                     	<== NOT EXECUTED

  /*
   *  If the thread wants to timeout, then schedule its timer.
   */
  if ( timeout ) {
   4823e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   48240:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   48244:	664a           	bnes 48290 <_Thread_queue_Enqueue_with_handler+0x70>	<== NOT EXECUTED
  }

  /*
   *  Now enqueue the thread per the discipline for this thread queue.
   */
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
   48246:	41f9 0004 82c4 	lea 482c4 <_Thread_queue_Enqueue_priority>,%a0    	<== NOT EXECUTED
   4824c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4824e:	b2ab 0034      	cmpl %a3@(52),%d1                                 	<== NOT EXECUTED
   48252:	6706           	beqs 4825a <_Thread_queue_Enqueue_with_handler+0x3a>	<== NOT EXECUTED
   48254:	41f9 0004 b820 	lea 4b820 <_Thread_queue_Enqueue_fifo>,%a0        	<== 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 );
   4825a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4825e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48260:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   48262:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
  if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
   48264:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4826a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4826c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4826e:	6714           	beqs 48284 <_Thread_queue_Enqueue_with_handler+0x64>	<== NOT EXECUTED
    _Thread_blocking_operation_Cancel( sync_state, the_thread, level );
   48270:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   48274:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48276:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48278:	4eb9 0004 772c 	jsr 4772c <_Thread_blocking_operation_Cancel>     	<== NOT EXECUTED
   4827e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   48284:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   48288:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   4828c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4828e:	4e75           	rts                                               	<== NOT EXECUTED

  /*
   *  If the thread wants to timeout, then schedule its timer.
   */
  if ( timeout ) {
    _Watchdog_Initialize(
   48290:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   48294:	2540 0068      	movel %d0,%a2@(104)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   48298:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4829c:	256e 0010 0064 	movel %fp@(16),%a2@(100)                          	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   482a2:	2540 0054      	movel %d0,%a2@(84)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   482a6:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   482aa:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   482ae:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   482b2:	4879 0005 8830 	pea 58830 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   482b8:	4eb9 0004 8ed4 	jsr 48ed4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   482be:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   482c0:	6084           	bras 48246 <_Thread_queue_Enqueue_with_handler+0x26>	<== NOT EXECUTED
	...

0004b87c <_Thread_queue_Extract>:

void _Thread_queue_Extract(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   4b87c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b880:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   4b884:	202e 000c      	movel %fp@(12),%d0                                	<== 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 )
   4b888:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4b88a:	b2a8 0034      	cmpl %a0@(52),%d1                                 	<== NOT EXECUTED
   4b88e:	6710           	beqs 4b8a0 <_Thread_queue_Extract+0x24>           	<== NOT EXECUTED
    _Thread_queue_Extract_priority( the_thread_queue, the_thread );
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
    _Thread_queue_Extract_fifo( the_thread_queue, the_thread );
   4b890:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4b894:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED

}
   4b898:	4e5e           	unlk %fp                                          	<== 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 );
   4b89a:	4ef9 0004 c540 	jmp 4c540 <_Thread_queue_Extract_fifo>            	<== NOT EXECUTED
  /*
   * Can not use indirect function pointer here since Extract priority
   * is a macro and the underlying methods do not have the same signature.
   */
  if  ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
    _Thread_queue_Extract_priority( the_thread_queue, the_thread );
   4b8a0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4b8a2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4b8a4:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4b8a6:	4eb9 0004 b8b8 	jsr 4b8b8 <_Thread_queue_Extract_priority_helper> 	<== NOT EXECUTED
   4b8ac:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
    _Thread_queue_Extract_fifo( the_thread_queue, the_thread );

}
   4b8b2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b8b4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c540 <_Thread_queue_Extract_fifo>:

void _Thread_queue_Extract_fifo(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   4c540:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c544:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4c546:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4c54a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4c550:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4c552:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4c554:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   4c556:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4c55a:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   4c560:	6734           	beqs 4c596 <_Thread_queue_Extract_fifo+0x56>      	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   4c562:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   4c564:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
    return;
  }

  _Chain_Extract_unprotected( &the_thread->Object.Node );

  the_thread->Wait.queue = NULL;
   4c568:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4c56c:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   4c56e:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4c570:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
   4c574:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4c578:	6726           	beqs 4c5a0 <_Thread_queue_Extract_fifo+0x60>      	<== NOT EXECUTED
    _ISR_Enable( level );
   4c57a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   4c57c:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4c580:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4c584:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
   4c58a:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4c58e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c590:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );

  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
    _ISR_Enable( level );
   4c596:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4c598:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4c59c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c59e:	4e75           	rts                                               	<== NOT EXECUTED
   4c5a0:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4c5a2:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
    _ISR_Enable( level );
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4c5a6:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4c5a8:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4c5ac:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   4c5b2:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4c5b6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4c5ba:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
    _ISR_Enable( level );
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
    (void) _Watchdog_Remove( &the_thread->Timer );
   4c5c0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4c5c2:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif

}
   4c5c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c5c8:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
	...

0004b8b8 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  bool                  requeuing
)
{
   4b8b8:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4b8bc:	48d7 3c04      	moveml %d2/%a2-%a5,%sp@                           	<== NOT EXECUTED
   4b8c0:	246e 000c      	moveal %fp@(12),%a2                               	<== 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 );
   4b8c4:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
void _Thread_queue_Extract_priority_helper(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  bool                  requeuing
)
{
   4b8ca:	142e 0013      	moveb %fp@(19),%d2                                	<== 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 );
   4b8ce:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4b8d0:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4b8d2:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   4b8d4:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4b8d8:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   4b8de:	6774           	beqs 4b954 <_Thread_queue_Extract_priority_helper+0x9c>	<== NOT EXECUTED

  /*
   *  The thread was actually waiting on a thread queue so let's remove it.
   */

  next_node     = the_node->next;
   4b8e0:	2652           	moveal %a2@,%a3                                   	<== NOT EXECUTED
  previous_node = the_node->previous;
   4b8e2:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   4b8e6:	206a 0038      	moveal %a2@(56),%a0                               	<== NOT EXECUTED

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
   4b8ea:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4b8ec:	0680 0000 003c 	addil #60,%d0                                     	<== NOT EXECUTED
   4b8f2:	b088           	cmpl %a0,%d0                                      	<== NOT EXECUTED
   4b8f4:	6776           	beqs 4b96c <_Thread_queue_Extract_priority_helper+0xb4>	<== 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;
   4b8f6:	2a6a 0040      	moveal %a2@(64),%a5                               	<== NOT EXECUTED
    new_second_node  = new_first_node->next;
   4b8fa:	2850           	moveal %a0@,%a4                                   	<== NOT EXECUTED

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
   4b8fc:	2748 0004      	movel %a0,%a3@(4)                                 	<== 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;
    new_second_node  = new_first_node->next;

    previous_node->next      = new_first_node;
   4b900:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
    new_first_node->previous = previous_node;
   4b902:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
    last_node        = the_thread->Wait.Block2n.last;
    new_second_node  = new_first_node->next;

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
   4b906:	208b           	movel %a3,%a0@                                    	<== NOT EXECUTED
    new_first_node->previous = previous_node;

    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
   4b908:	202a 0040      	movel %a2@(64),%d0                                	<== NOT EXECUTED
   4b90c:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   4b910:	6718           	beqs 4b92a <_Thread_queue_Extract_priority_helper+0x72>	<== NOT EXECUTED
                                        /* > two threads on 2-n */
      new_second_node->previous =
   4b912:	43e8 0038      	lea %a0@(56),%a1                                  	<== NOT EXECUTED
   4b916:	2949 0004      	movel %a1,%a4@(4)                                 	<== NOT EXECUTED
                _Chain_Head( &new_first_thread->Wait.Block2n );
      new_first_thread->Wait.Block2n.first = new_second_node;
   4b91a:	214c 0038      	movel %a4,%a0@(56)                                	<== NOT EXECUTED

      new_first_thread->Wait.Block2n.last = last_node;
   4b91e:	214d 0040      	movel %a5,%a0@(64)                                	<== NOT EXECUTED
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
   4b922:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
   4b928:	2a88           	movel %a0,%a5@                                    	<== NOT EXECUTED

  /*
   *  If we are not supposed to touch timers or the thread's state, return.
   */

  if ( requeuing ) {
   4b92a:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4b92c:	6632           	bnes 4b960 <_Thread_queue_Extract_priority_helper+0xa8>	<== NOT EXECUTED
    _ISR_Enable( level );
    return;
  }

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4b92e:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4b930:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4b934:	673e           	beqs 4b974 <_Thread_queue_Extract_priority_helper+0xbc>	<== NOT EXECUTED
    _ISR_Enable( level );
   4b936:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4b938:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif
}
   4b93c:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4b942:	227c 1003 fff8 	moveal #268697592,%a1                             	<== NOT EXECUTED
   4b948:	2d49 000c      	movel %a1,%fp@(12)                                	<== NOT EXECUTED
   4b94c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b94e:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED
  Chain_Node     *last_node;

  the_node = (Chain_Node *) the_thread;
  _ISR_Disable( level );
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
    _ISR_Enable( level );
   4b954:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif
}
   4b956:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4b95c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b95e:	4e75           	rts                                               	<== NOT EXECUTED
  /*
   *  If we are not supposed to touch timers or the thread's state, return.
   */

  if ( requeuing ) {
    _ISR_Enable( level );
   4b960:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif
}
   4b962:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4b968:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b96a:	4e75           	rts                                               	<== NOT EXECUTED
      new_first_thread->Wait.Block2n.last = last_node;
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
    }
  } else {
    previous_node->next = next_node;
    next_node->previous = previous_node;
   4b96c:	2749 0004      	movel %a1,%a3@(4)                                 	<== NOT EXECUTED

      new_first_thread->Wait.Block2n.last = last_node;
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
    }
  } else {
    previous_node->next = next_node;
   4b970:	228b           	movel %a3,%a1@                                    	<== NOT EXECUTED
   4b972:	60b6           	bras 4b92a <_Thread_queue_Extract_priority_helper+0x72>	<== NOT EXECUTED
   4b974:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4b976:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
    _ISR_Enable( level );
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4b97a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4b97c:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4b980:	4eb9 0004 901c 	jsr 4901c <_Watchdog_Remove>                      	<== NOT EXECUTED
   4b986:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
   4b98a:	227c 1003 fff8 	moveal #268697592,%a1                             	<== NOT EXECUTED
   4b990:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4b992:	2d49 000c      	movel %a1,%fp@(12)                                	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
    _Thread_MP_Free_proxy( the_thread );
#endif
}
   4b996:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4b99c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b99e:	4ef9 0004 78e4 	jmp 478e4 <_Thread_Clear_state>                   	<== NOT EXECUTED

00048474 <_Thread_queue_Extract_with_proxy>:
 */

bool _Thread_queue_Extract_with_proxy(
  Thread_Control       *the_thread
)
{
   48474:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48478:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  States_Control                state;

  state = the_thread->current_state;

  if ( _States_Is_waiting_on_thread_queue( state ) ) {
   4847c:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
   48480:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   48486:	6604           	bnes 4848c <_Thread_queue_Extract_with_proxy+0x18>	<== NOT EXECUTED
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );

    return TRUE;
  }
  return FALSE;
}
   48488:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4848a:	4e75           	rts                                               	<== NOT EXECUTED

        if ( proxy_extract_callout )
          (*proxy_extract_callout)( the_thread );
      }
    #endif
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
   4848c:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4848e:	2f28 0044      	movel %a0@(68),%sp@-                              	<== NOT EXECUTED
   48492:	4eb9 0004 b87c 	jsr 4b87c <_Thread_queue_Extract>                 	<== NOT EXECUTED
   48498:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

    return TRUE;
  }
  return FALSE;
}
   4849a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

        if ( proxy_extract_callout )
          (*proxy_extract_callout)( the_thread );
      }
    #endif
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
   4849c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

    return TRUE;
  }
  return FALSE;
}
   4849e:	4e75           	rts

0005a0b4 <_Thread_queue_First>:
 */

Thread_Control *_Thread_queue_First(
  Thread_queue_Control *the_thread_queue
)
{
   5a0b4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5a0b8:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  Thread_Control * (*first_p)(Thread_queue_Control *);

  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
   5a0bc:	203c 0005 a0dc 	movel #368860,%d0                                 	<== NOT EXECUTED
   5a0c2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   5a0c4:	b2a8 0034      	cmpl %a0@(52),%d1                                 	<== NOT EXECUTED
   5a0c8:	6706           	beqs 5a0d0 <_Thread_queue_First+0x1c>             	<== NOT EXECUTED
   5a0ca:	203c 0005 ac1c 	movel #371740,%d0                                 	<== 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 );
   5a0d0:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
}
   5a0d4:	4e5e           	unlk %fp                                          	<== 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 );
   5a0d6:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   5a0d8:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
	...

0005ac1c <_Thread_queue_First_fifo>:
 */

Thread_Control *_Thread_queue_First_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   5ac1c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   5ac20:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   5ac24:	2018           	movel %a0@+,%d0                                   	<== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
   5ac26:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   5ac28:	6704           	beqs 5ac2e <_Thread_queue_First_fifo+0x12>        	<== NOT EXECUTED
    return (Thread_Control *) the_thread_queue->Queues.Fifo.first;

  return NULL;
}
   5ac2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5ac2c:	4e75           	rts                                               	<== NOT EXECUTED
   5ac2e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

Thread_Control *_Thread_queue_First_fifo(
  Thread_queue_Control *the_thread_queue
)
{
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
   5ac30:	4280           	clrl %d0                                          	<== NOT EXECUTED
    return (Thread_Control *) the_thread_queue->Queues.Fifo.first;

  return NULL;
}
   5ac32:	4e75           	rts

0005a0dc <_Thread_queue_First_priority>:
 */

Thread_Control *_Thread_queue_First_priority (
  Thread_queue_Control *the_thread_queue
)
{
   5a0dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5a0e0:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5a0e2:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   5a0e6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5a0e8:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   5a0ea:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   5a0ec:	2012           	movel %a2@,%d0                                    	<== 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 ] ) )
   5a0ee:	41f1 9a01      	lea %a1@(00000001,%a1:l:2),%a0                    	<== NOT EXECUTED
{
  uint32_t   index;

  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
       index++ ) {
   5a0f2:	d5fc 0000 000c 	addal #12,%a2                                     	<== NOT EXECUTED
   5a0f8:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
   5a0fa:	41f3 8c00      	lea %a3@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   5a0fe:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   5a100:	6608           	bnes 5a10a <_Thread_queue_First_priority+0x2e>    	<== NOT EXECUTED
)
{
  uint32_t   index;

  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
   5a102:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5a104:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   5a106:	66e4           	bnes 5a0ec <_Thread_queue_First_priority+0x10>    	<== NOT EXECUTED
   5a108:	4200           	clrb %d0                                          	<== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
      return (Thread_Control *)
        the_thread_queue->Queues.Priority[ index ].first;
  }
  return NULL;
}
   5a10a:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   5a10c:	265f           	moveal %sp@+,%a3                                  	<== NOT EXECUTED
   5a10e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5a110:	4e75           	rts                                               	<== NOT EXECUTED
	...

000484a0 <_Thread_queue_Flush>:
void _Thread_queue_Flush(
  Thread_queue_Control       *the_thread_queue,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   484a0:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   484a4:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   484a8:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   484ac:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
  Thread_Control *the_thread;

  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
   484b0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   484b2:	45f9 0004 80b8 	lea 480b8 <_Thread_queue_Dequeue>,%a2             	<== NOT EXECUTED
   484b8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   484ba:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   484bc:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   484be:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   484c0:	6710           	beqs 484d2 <_Thread_queue_Flush+0x32>             	<== 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;
   484c2:	2142 0034      	movel %d2,%a0@(52)                                	<== NOT EXECUTED
  uint32_t                    status
)
{
  Thread_Control *the_thread;

  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
   484c6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   484c8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   484ca:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   484cc:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   484ce:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   484d0:	66f0           	bnes 484c2 <_Thread_queue_Flush+0x22>             	<== NOT EXECUTED
      ( *remote_extract_callout )( the_thread );
    else
#endif
      the_thread->Wait.return_code = status;
  }
}
   484d2:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   484d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   484da:	4e75           	rts

000484dc <_Thread_queue_Initialize>:
  Thread_queue_Control         *the_thread_queue,
  Thread_queue_Disciplines      the_discipline,
  States_Control                state,
  uint32_t                      timeout_status
)
{
   484dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   484e0:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  the_thread_queue->state          = state;
   484e4:	216e 0010 0038 	movel %fp@(16),%a0@(56)                           	<== NOT EXECUTED
  Thread_queue_Control         *the_thread_queue,
  Thread_queue_Disciplines      the_discipline,
  States_Control                state,
  uint32_t                      timeout_status
)
{
   484ea:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
  the_thread_queue->state          = state;
  the_thread_queue->discipline     = the_discipline;
  the_thread_queue->timeout_status = timeout_status;
   484ee:	216e 0014 003c 	movel %fp@(20),%a0@(60)                           	<== NOT EXECUTED
  the_thread_queue->sync_state     = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;

  if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
   484f4:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  States_Control                state,
  uint32_t                      timeout_status
)
{
  the_thread_queue->state          = state;
  the_thread_queue->discipline     = the_discipline;
   484f6:	2140 0034      	movel %d0,%a0@(52)                                	<== NOT EXECUTED
  the_thread_queue->timeout_status = timeout_status;
  the_thread_queue->sync_state     = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   484fa:	42a8 0030      	clrl %a0@(48)                                     	<== NOT EXECUTED

  if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
   484fe:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   48500:	6712           	beqs 48514 <_Thread_queue_Initialize+0x38>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48502:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   48504:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   48506:	2148 0008      	movel %a0,%a0@(8)                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4850a:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4850c:	42a8 0004      	clrl %a0@(4)                                      	<== 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 );
  }

}
   48510:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48512:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48514:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   48516:	5889           	addql #4,%a1                                      	<== NOT EXECUTED
   48518:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4851a:	43e8 0024      	lea %a0@(36),%a1                                  	<== NOT EXECUTED
   4851e:	2149 002c      	movel %a1,%a0@(44)                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48522:	43e8 0010      	lea %a0@(16),%a1                                  	<== NOT EXECUTED
   48526:	2149 000c      	movel %a1,%a0@(12)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4852a:	43e8 000c      	lea %a0@(12),%a1                                  	<== NOT EXECUTED
   4852e:	2149 0014      	movel %a1,%a0@(20)                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48532:	43e8 001c      	lea %a0@(28),%a1                                  	<== NOT EXECUTED
   48536:	2149 0018      	movel %a1,%a0@(24)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4853a:	43e8 0018      	lea %a0@(24),%a1                                  	<== NOT EXECUTED
   4853e:	2149 0020      	movel %a1,%a0@(32)                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48542:	43e8 0028      	lea %a0@(40),%a1                                  	<== NOT EXECUTED
   48546:	2149 0024      	movel %a1,%a0@(36)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4854a:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   4854e:	2148 0008      	movel %a0,%a0@(8)                                 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   48552:	42a8 0010      	clrl %a0@(16)                                     	<== NOT EXECUTED
   48556:	42a8 001c      	clrl %a0@(28)                                     	<== NOT EXECUTED
   4855a:	42a8 0028      	clrl %a0@(40)                                     	<== NOT EXECUTED
   4855e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48560:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b9a4 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>

void _Thread_queue_Process_timeout(
  Thread_Control *the_thread
)
{
   4b9a4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b9a8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
   4b9ac:	2069 0044      	moveal %a1@(68),%a0                               	<== 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 &&
   4b9b0:	2028 0030      	movel %a0@(48),%d0                                	<== NOT EXECUTED
   4b9b4:	6708           	beqs 4b9be <_Thread_queue_Process_timeout+0x1a>   	<== NOT EXECUTED
   4b9b6:	b3f9 0005 8812 	cmpal 58812 <_Thread_Executing>,%a1               	<== NOT EXECUTED
   4b9bc:	6718           	beqs 4b9d6 <_Thread_queue_Process_timeout+0x32>   	<== NOT EXECUTED
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
    }
  } else {
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
   4b9be:	2368 003c 0034 	movel %a0@(60),%a1@(52)                           	<== NOT EXECUTED
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
   4b9c4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   4b9c6:	2f29 0044      	movel %a1@(68),%sp@-                              	<== NOT EXECUTED
   4b9ca:	4eb9 0004 b87c 	jsr 4b87c <_Thread_queue_Extract>                 	<== NOT EXECUTED
   4b9d0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  }
}
   4b9d2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b9d4:	4e75           	rts                                               	<== NOT EXECUTED
   *  a timeout is not allowed to occur.
   */

  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
       _Thread_Is_executing( the_thread ) ) {
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
   4b9d6:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4b9d8:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4b9da:	67f6           	beqs 4b9d2 <_Thread_queue_Process_timeout+0x2e>   	<== NOT EXECUTED
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   4b9dc:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   */

  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
       _Thread_Is_executing( the_thread ) ) {
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
   4b9de:	2368 003c 0034 	movel %a0@(60),%a1@(52)                           	<== NOT EXECUTED
    }
  } else {
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
  }
}
   4b9e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
       _Thread_Is_executing( the_thread ) ) {
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   4b9e6:	2140 0030      	movel %d0,%a0@(48)                                	<== NOT EXECUTED
    }
  } else {
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
  }
}
   4b9ea:	4e75           	rts

00048564 <_Thread_queue_Requeue>:

void _Thread_queue_Requeue(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   48564:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   48568:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4856a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4856e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  /*
   * Just in case the thread really wasn't blocked on a thread queue
   * when we get here.
   */
  if ( !the_thread_queue )
   48570:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   48572:	6708           	beqs 4857c <_Thread_queue_Requeue+0x18>           	<== 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 ) {
   48574:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   48576:	b0aa 0034      	cmpl %a2@(52),%d0                                 	<== NOT EXECUTED
   4857a:	670c           	beqs 48588 <_Thread_queue_Requeue+0x24>           	<== NOT EXECUTED
      _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    }
    _ISR_Enable( level );
  }
}
   4857c:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   48580:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   48584:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48586:	4e75           	rts                                               	<== NOT EXECUTED
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
    Thread_queue_Control *tq = the_thread_queue;
    ISR_Level             level;
    ISR_Level             level_ignored;

    _ISR_Disable( level );
   48588:	303c 0700      	movew #1792,%d0                                   	<== NOT EXECUTED
   4858c:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   4858e:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   48590:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   48592:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   48596:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
   4859a:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   485a0:	660e           	bnes 485b0 <_Thread_queue_Requeue+0x4c>           	<== NOT EXECUTED
      _Thread_queue_Enter_critical_section( tq );
      _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    }
    _ISR_Enable( level );
   485a2:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  }
}
   485a4:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   485a8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   485ac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   485ae:	4e75           	rts                                               	<== NOT EXECUTED
    ISR_Level             level_ignored;

    _ISR_Disable( level );
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
      _Thread_queue_Enter_critical_section( tq );
      _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
   485b0:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   485b4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   485b6:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
   485ba:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   485bc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   485be:	4eb9 0004 b8b8 	jsr 4b8b8 <_Thread_queue_Extract_priority_helper> 	<== NOT EXECUTED
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
   485c4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   485c8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   485cc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   485ce:	4eb9 0004 82c4 	jsr 482c4 <_Thread_queue_Enqueue_priority>        	<== NOT EXECUTED
   485d4:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
    }
    _ISR_Enable( level );
   485da:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   485dc:	60c6           	bras 485a4 <_Thread_queue_Requeue+0x40>           	<== NOT EXECUTED
	...

000485e0 <_Thread_queue_Timeout>:

void _Thread_queue_Timeout(
  Objects_Id  id,
  void       *ignored
)
{
   485e0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  Thread_Control       *the_thread;
  Objects_Locations     location;

  the_thread = _Thread_Get( id, &location );
   485e4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   485e8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   485ec:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   485f2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   485f4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   485f8:	6618           	bnes 48612 <_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 );
   485fa:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   485fc:	4eb9 0004 b9a4 	jsr 4b9a4 <_Thread_queue_Process_timeout>         	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   48602:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   48608:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4860a:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4860c:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
      _Thread_Unnest_dispatch();
      break;
  }
}
   48612:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48614:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004ae54 <_Timer_Manager_initialization>:
 */

void _Timer_Manager_initialization(
  uint32_t   maximum_timers
)
{
   4ae54:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   4ae58:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   4ae5c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ae5e:	4878 003c      	pea 3c <DBL_MANT_DIG+0x7>                         	<== NOT EXECUTED
   4ae62:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ae66:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ae6a:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4ae6e:	4879 0005 8b3e 	pea 58b3e <_Timer_Information>                    	<== NOT EXECUTED
   4ae74:	4eb9 0004 74ac 	jsr 474ac <_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;
  _Timer_Server_schedule_operation = NULL;
   4ae7a:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
}
   4ae80:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  /*
   *  Initialize the pointer to the Timer Server TCB to NULL indicating
   *  that task-based timer support is not initialized.
   */

  _Timer_Server = NULL;
   4ae82:	42b9 0005 8b7e 	clrl 58b7e <_Timer_Server>                        	<== NOT EXECUTED
  _Timer_Server_schedule_operation = NULL;
   4ae88:	42b9 0005 8b7a 	clrl 58b7a <_Timer_Server_schedule_operation>     	<== NOT EXECUTED
}
   4ae8e:	4e75           	rts

000536ae <_Timer_Server_body>:

  /*
   *  Initialize the "last time" markers to indicate the timer that
   *  the server was initiated.
   */
  _Timer_Server_ticks_last_time   = _Watchdog_Ticks_since_boot;
   536ae:	2239 0007 1748 	movel 71748 <_Watchdog_Ticks_since_boot>,%d1      	<== NOT EXECUTED
 *  @param[in] ignored is the the task argument that is ignored
 */
Thread _Timer_Server_body(
  uint32_t   ignored
)
{
   536b4:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
   536b8:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   536be:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   536c2:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   536c4:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   536c6:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   536c8:	0684 ffff fff4 	addil #-12,%d4                                    	<== NOT EXECUTED
   536ce:	5183           	subql #8,%d3                                      	<== 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;
  _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
   536d0:	41f9 0007 1692 	lea 71692 <_TOD_Now>,%a0                          	<== 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;
   536d6:	23c1 0007 1568 	movel %d1,71568 <_Timer_Server_ticks_last_time>   	<== NOT EXECUTED
  _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
   536dc:	23d0 0007 1564 	movel %a0@,71564 <_Timer_Server_seconds_last_time>	<== NOT EXECUTED
   536e2:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   536e8:	2d43 fff4      	movel %d3,%fp@(-12)                               	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   536ec:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   536f0:	2d44 fffc      	movel %d4,%fp@(-4)                                	<== 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();
  _Thread_Enable_dispatch();
   536f4:	45f9 0005 62a4 	lea 562a4 <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   536fa:	4bf9 0005 6df4 	lea 56df4 <_Thread_Set_state>,%a5                 	<== NOT EXECUTED
   53700:	49f9 0005 7810 	lea 57810 <_Watchdog_Insert>,%a4                  	<== NOT EXECUTED
   53706:	47f9 0005 7958 	lea 57958 <_Watchdog_Remove>,%a3                  	<== NOT EXECUTED
     */
    while (1) {
      Watchdog_Control *watch;
      ISR_Level         level;

      _ISR_Disable( level );
   5370c:	2a3c 0000 0700 	movel #1792,%d5                                   	<== 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();
   53712:	2e3c 0005 3636 	movel #341558,%d7                                 	<== NOT EXECUTED
   53718:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   5371a:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   5371c:	2c3c 0005 7788 	movel #358280,%d6                                 	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   53722:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   53724:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   5372a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   5372c:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

    /*
     *  Block until there is something to do.
     */
    _Thread_Disable_dispatch();
      _Thread_Set_state( _Timer_Server, STATES_DELAYING );
   53732:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   53736:	2f39 0007 18c2 	movel 718c2 <_Timer_Server>,%sp@-                 	<== NOT EXECUTED
   5373c:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   5373e:	2279 0007 1558 	moveal 71558 <_Timer_Ticks_chain>,%a1             	<== NOT EXECUTED
      _Timer_Server_reset_ticks_timer();
   53744:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   53746:	b3fc 0007 155c 	cmpal #464220,%a1                                 	<== NOT EXECUTED
   5374c:	671a           	beqs 53768 <_Timer_Server_body+0xba>              	<== NOT EXECUTED
   5374e:	2079 0007 18c2 	moveal 718c2 <_Timer_Server>,%a0                  	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   53754:	2169 0010 0054 	movel %a1@(16),%a0@(84)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   5375a:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   5375e:	4879 0007 16dc 	pea 716dc <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   53764:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   53766:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   53768:	2079 0007 156c 	moveal 7156c <_Timer_Seconds_chain>,%a0           	<== NOT EXECUTED
      _Timer_Server_reset_seconds_timer();
   5376e:	b1fc 0007 1570 	cmpal #464240,%a0                                 	<== NOT EXECUTED
   53774:	671c           	beqs 53792 <_Timer_Server_body+0xe4>              	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   53776:	d1fc 0000 0010 	addal #16,%a0                                     	<== NOT EXECUTED
   5377c:	23d0 0007 1590 	movel %a0@,71590 <_Timer_Seconds_timer+0xc>       	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   53782:	4879 0007 1584 	pea 71584 <_Timer_Seconds_timer>                  	<== NOT EXECUTED
   53788:	4879 0007 16d0 	pea 716d0 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   5378e:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   53790:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   53792:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   53794:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   5379a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   5379c:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== 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();
   537a2:	2039 0007 18c2 	movel 718c2 <_Timer_Server>,%d0                   	<== NOT EXECUTED
   537a8:	0680 0000 0048 	addil #72,%d0                                     	<== NOT EXECUTED
   537ae:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   537b0:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
    _Timer_Server_stop_seconds_timer();
   537b2:	4879 0007 1584 	pea 71584 <_Timer_Seconds_timer>                  	<== NOT EXECUTED
   537b8:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
)
{
  Watchdog_Interval snapshot;
  Watchdog_Interval ticks;

  snapshot = _Watchdog_Ticks_since_boot;
   537ba:	2239 0007 1748 	movel 71748 <_Watchdog_Ticks_since_boot>,%d1      	<== NOT EXECUTED
  if ( snapshot >= _Timer_Server_ticks_last_time )
   537c0:	2039 0007 1568 	movel 71568 <_Timer_Server_ticks_last_time>,%d0   	<== NOT EXECUTED
   537c6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   537c8:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   537ca:	6200 00de      	bhiw 538aa <_Timer_Server_body+0x1fc>             	<== 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 );
   537ce:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
  Watchdog_Interval snapshot;
  Watchdog_Interval ticks;

  snapshot = _Watchdog_Ticks_since_boot;
  if ( snapshot >= _Timer_Server_ticks_last_time )
     ticks = snapshot - _Timer_Server_ticks_last_time;
   537d0:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   537d2:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   537d4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
  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 );
   537d6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   537d8:	2046           	moveal %d6,%a0                                    	<== NOT EXECUTED
   537da:	4879 0007 1558 	pea 71558 <_Timer_Ticks_chain>                    	<== NOT EXECUTED
  if ( snapshot >= _Timer_Server_ticks_last_time )
     ticks = snapshot - _Timer_Server_ticks_last_time;
  else
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;

  _Timer_Server_ticks_last_time = snapshot;
   537e0:	23c1 0007 1568 	movel %d1,71568 <_Timer_Server_ticks_last_time>   	<== NOT EXECUTED
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
   537e6:	4e90           	jsr %a0@                                          	<== 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;
   537e8:	2439 0007 1692 	movel 71692 <_TOD_Now>,%d2                        	<== NOT EXECUTED
  if ( snapshot > _Timer_Server_seconds_last_time ) {
   537ee:	2039 0007 1564 	movel 71564 <_Timer_Server_seconds_last_time>,%d0 	<== NOT EXECUTED
   537f4:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   537fa:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   537fc:	6500 00dc      	bcsw 538da <_Timer_Server_body+0x22c>             	<== NOT EXECUTED
     *  TOD has been set forward.
     */
    ticks = snapshot - _Timer_Server_seconds_last_time;
    _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );

  } else if ( snapshot < _Timer_Server_seconds_last_time ) {
   53800:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   53802:	6200 0088      	bhiw 5388c <_Timer_Server_body+0x1de>             	<== NOT EXECUTED
    _Timer_Server_process_seconds_chain( &to_fire );

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   53806:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
      *  TOD has been set backwards.
      */
     ticks = _Timer_Server_seconds_last_time - snapshot;
     _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
  }
  _Timer_Server_seconds_last_time = snapshot;
   53808:	23c2 0007 1564 	movel %d2,71564 <_Timer_Server_seconds_last_time> 	<== NOT EXECUTED
    _Timer_Server_process_seconds_chain( &to_fire );

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   5380e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

    /*
     * Enable dispatching to process the set that are ready "to fire."
     */
    _Thread_Enable_dispatch();
   53810:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
     */
    while (1) {
      Watchdog_Control *watch;
      ISR_Level         level;

      _ISR_Disable( level );
   53812:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   53814:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   53816:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   53818:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   5381a:	226e fff4      	moveal %fp@(-12),%a1                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   5381e:	b3c3           	cmpal %d3,%a1                                     	<== NOT EXECUTED
   53820:	6764           	beqs 53886 <_Timer_Server_body+0x1d8>             	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   53822:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   53824:	2d48 fff4      	movel %a0,%fp@(-12)                               	<== NOT EXECUTED
      if ( watch == NULL ) {
        _ISR_Enable( level );
        break;
      }

      watch->state = WATCHDOG_INACTIVE;
   53828:	42a9 0008      	clrl %a1@(8)                                      	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   5382c:	2144 0004      	movel %d4,%a0@(4)                                 	<== NOT EXECUTED
      _ISR_Enable( level );
   53830:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

      (*watch->routine)( watch->id, watch->user_data );
   53832:	2f29 0024      	movel %a1@(36),%sp@-                              	<== NOT EXECUTED
   53836:	2f29 0020      	movel %a1@(32),%sp@-                              	<== NOT EXECUTED
   5383a:	2069 001c      	moveal %a1@(28),%a0                               	<== NOT EXECUTED
   5383e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
     */
    while (1) {
      Watchdog_Control *watch;
      ISR_Level         level;

      _ISR_Disable( level );
   53840:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   53842:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   53844:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   53846:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   53848:	206e fff4      	moveal %fp@(-12),%a0                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   5384c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
   5384e:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   53850:	b1c3           	cmpal %d3,%a0                                     	<== NOT EXECUTED
   53852:	6732           	beqs 53886 <_Timer_Server_body+0x1d8>             	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   53854:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   53856:	2d48 fff4      	movel %a0,%fp@(-12)                               	<== NOT EXECUTED
      if ( watch == NULL ) {
        _ISR_Enable( level );
        break;
      }

      watch->state = WATCHDOG_INACTIVE;
   5385a:	42a9 0008      	clrl %a1@(8)                                      	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   5385e:	2144 0004      	movel %d4,%a0@(4)                                 	<== NOT EXECUTED
      _ISR_Enable( level );
   53862:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

      (*watch->routine)( watch->id, watch->user_data );
   53864:	2f29 0024      	movel %a1@(36),%sp@-                              	<== NOT EXECUTED
   53868:	2f29 0020      	movel %a1@(32),%sp@-                              	<== NOT EXECUTED
   5386c:	2069 001c      	moveal %a1@(28),%a0                               	<== NOT EXECUTED
   53870:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
     */
    while (1) {
      Watchdog_Control *watch;
      ISR_Level         level;

      _ISR_Disable( level );
   53872:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   53874:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   53876:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   53878:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   5387a:	206e fff4      	moveal %fp@(-12),%a0                              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   5387e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
   53880:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   53882:	b1c3           	cmpal %d3,%a0                                     	<== NOT EXECUTED
   53884:	66ce           	bnes 53854 <_Timer_Server_body+0x1a6>             	<== NOT EXECUTED
      if ( watch == NULL ) {
        _ISR_Enable( level );
   53886:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   53888:	6000 fe9a      	braw 53724 <_Timer_Server_body+0x76>              	<== 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 );
   5388c:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
   5388e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   53890:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   53894:	4879 0007 156c 	pea 7156c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   5389a:	4eb9 0005 76f4 	jsr 576f4 <_Watchdog_Adjust>                      	<== NOT EXECUTED
   538a0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   538a6:	6000 ff5e      	braw 53806 <_Timer_Server_body+0x158>             	<== 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 );
   538aa:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED

  snapshot = _Watchdog_Ticks_since_boot;
  if ( snapshot >= _Timer_Server_ticks_last_time )
     ticks = snapshot - _Timer_Server_ticks_last_time;
  else
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
   538ac:	4680           	notl %d0                                          	<== NOT EXECUTED
   538ae:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED

  _Timer_Server_ticks_last_time = snapshot;
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
   538b0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   538b2:	2046           	moveal %d6,%a0                                    	<== NOT EXECUTED
   538b4:	4879 0007 1558 	pea 71558 <_Timer_Ticks_chain>                    	<== NOT EXECUTED
  if ( snapshot >= _Timer_Server_ticks_last_time )
     ticks = snapshot - _Timer_Server_ticks_last_time;
  else
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;

  _Timer_Server_ticks_last_time = snapshot;
   538ba:	23c1 0007 1568 	movel %d1,71568 <_Timer_Server_ticks_last_time>   	<== NOT EXECUTED
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
   538c0:	4e90           	jsr %a0@                                          	<== 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;
   538c2:	2439 0007 1692 	movel 71692 <_TOD_Now>,%d2                        	<== NOT EXECUTED
  if ( snapshot > _Timer_Server_seconds_last_time ) {
   538c8:	2039 0007 1564 	movel 71564 <_Timer_Server_seconds_last_time>,%d0 	<== NOT EXECUTED
   538ce:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   538d4:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   538d6:	6400 ff28      	bccw 53800 <_Timer_Server_body+0x152>             	<== 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 );
   538da:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   538dc:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   538de:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   538e0:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   538e2:	4879 0007 156c 	pea 7156c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   538e8:	4eb9 0005 7788 	jsr 57788 <_Watchdog_Adjust_to_chain>             	<== NOT EXECUTED
   538ee:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   538f4:	6000 ff10      	braw 53806 <_Timer_Server_body+0x158>             	<== NOT EXECUTED

00053636 <_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)
{
   53636:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   5363a:	48d7 1c00      	moveml %a2-%a4,%sp@                               	<== NOT EXECUTED
   5363e:	45f9 0005 406c 	lea 5406c <_Chain_Get>,%a2                        	<== NOT EXECUTED
  Timer_Control *the_timer;

  while ( 1 ) {
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
   53644:	4879 0007 1578 	pea 71578 <_Timer_To_be_inserted>                 	<== NOT EXECUTED
   5364a:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
      break;

    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
   5364c:	49f9 0005 7810 	lea 57810 <_Watchdog_Insert>,%a4                  	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   53652:	47fa ffe2      	lea %pc@(53636 <_Timer_Server_process_insertions>),%a3	<== NOT EXECUTED
static void _Timer_Server_process_insertions(void)
{
  Timer_Control *the_timer;

  while ( 1 ) {
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
   53656:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
    if ( the_timer == NULL )
   53658:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   5365a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5365c:	6722           	beqs 53680 <_Timer_Server_process_insertions+0x4a>	<== NOT EXECUTED
      break;

    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
   5365e:	2028 0038      	movel %a0@(56),%d0                                	<== NOT EXECUTED
   53662:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   53664:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   53666:	6734           	beqs 5369c <_Timer_Server_process_insertions+0x66>	<== NOT EXECUTED
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
   53668:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   5366a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   5366c:	671c           	beqs 5368a <_Timer_Server_process_insertions+0x54>	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   5366e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
static void _Timer_Server_process_insertions(void)
{
  Timer_Control *the_timer;

  while ( 1 ) {
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
   53670:	4879 0007 1578 	pea 71578 <_Timer_To_be_inserted>                 	<== NOT EXECUTED
   53676:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
    if ( the_timer == NULL )
   53678:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
static void _Timer_Server_process_insertions(void)
{
  Timer_Control *the_timer;

  while ( 1 ) {
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
   5367a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
    if ( the_timer == NULL )
   5367c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5367e:	66de           	bnes 5365e <_Timer_Server_process_insertions+0x28>	<== NOT EXECUTED
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
  }

}
   53680:	4cee 1c00 fff4 	moveml %fp@(-12),%a2-%a4                          	<== NOT EXECUTED
   53686:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53688:	4e75           	rts                                               	<== NOT EXECUTED
      break;

    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
   5368a:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   5368e:	4879 0007 156c 	pea 7156c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   53694:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   53696:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   53698:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   5369a:	60d4           	bras 53670 <_Timer_Server_process_insertions+0x3a>	<== NOT EXECUTED
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
    if ( the_timer == NULL )
      break;

    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
   5369c:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   536a0:	4879 0007 1558 	pea 71558 <_Timer_Ticks_chain>                    	<== NOT EXECUTED
   536a6:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   536a8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   536aa:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   536ac:	60c2           	bras 53670 <_Timer_Server_process_insertions+0x3a>	<== NOT EXECUTED

000535f2 <_Timer_Server_schedule_operation_method>:
 *        the directive invoking this is executed.
 */
static void _Timer_Server_schedule_operation_method(
  Timer_Control     *the_timer
)
{
   535f2:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node );
   535f6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   535fa:	4879 0007 1578 	pea 71578 <_Timer_To_be_inserted>                 	<== NOT EXECUTED
   53600:	4eb9 0005 4034 	jsr 54034 <_Chain_Append>                         	<== NOT EXECUTED
  _Watchdog_Remove( &_Timer_Server->Timer );
   53606:	2039 0007 18c2 	movel 718c2 <_Timer_Server>,%d0                   	<== NOT EXECUTED
   5360c:	0680 0000 0048 	addil #72,%d0                                     	<== NOT EXECUTED
   53612:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   53614:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
  _Thread_Delay_ended( _Timer_Server->Object.id, NULL );
   5361a:	2079 0007 18c2 	moveal 718c2 <_Timer_Server>,%a0                  	<== NOT EXECUTED
   53620:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   53622:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   53626:	4eb9 0005 610c 	jsr 5610c <_Thread_Delay_ended>                   	<== NOT EXECUTED
   5362c:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
}
   53632:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53634:	4e75           	rts

00048ba0 <_Timespec_Add_to>:

uint32_t _Timespec_Add_to(
  struct timespec       *time,
  const struct timespec *add
)
{
   48ba0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48ba4:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   48ba8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  uint32_t seconds = add->tv_sec;

  /* Add the basics */
  time->tv_sec += add->tv_sec;
  time->tv_nsec += add->tv_nsec;
   48bac:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED

uint32_t _Timespec_Add_to(
  struct timespec       *time,
  const struct timespec *add
)
{
   48bb0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t seconds = add->tv_sec;
   48bb2:	2410           	movel %a0@,%d2                                    	<== NOT EXECUTED

  /* Add the basics */
  time->tv_sec += add->tv_sec;
  time->tv_nsec += add->tv_nsec;
   48bb4:	d0a9 0004      	addl %a1@(4),%d0                                  	<== NOT EXECUTED
)
{
  uint32_t seconds = add->tv_sec;

  /* Add the basics */
  time->tv_sec += add->tv_sec;
   48bb8:	d591           	addl %d2,%a1@                                     	<== NOT EXECUTED
  time->tv_nsec += add->tv_nsec;

  /* Now adjust it so nanoseconds is in range */
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
   48bba:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
{
  uint32_t seconds = add->tv_sec;

  /* Add the basics */
  time->tv_sec += add->tv_sec;
  time->tv_nsec += add->tv_nsec;
   48bbc:	2340 0004      	movel %d0,%a1@(4)                                 	<== NOT EXECUTED

  /* Now adjust it so nanoseconds is in range */
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
   48bc0:	0c80 3b9a c9ff 	cmpil #999999999,%d0                              	<== NOT EXECUTED
   48bc6:	631a           	blss 48be2 <_Timespec_Add_to+0x42>                	<== NOT EXECUTED
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
   48bc8:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
    time->tv_sec++;
   48bca:	5291           	addql #1,%a1@                                     	<== NOT EXECUTED
  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 ) {
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
   48bcc:	0680 c465 3600 	addil #-1000000000,%d0                            	<== NOT EXECUTED
    time->tv_sec++;
    seconds++;
   48bd2:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
  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 ) {
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
   48bd4:	2340 0004      	movel %d0,%a1@(4)                                 	<== 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 ) {
   48bd8:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   48bda:	0c80 3b9a c9ff 	cmpil #999999999,%d0                              	<== NOT EXECUTED
   48be0:	62e6           	bhis 48bc8 <_Timespec_Add_to+0x28>                	<== NOT EXECUTED
    time->tv_sec++;
    seconds++;
  }

  return seconds;
}
   48be2:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   48be4:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   48be6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48be8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a1cc <_Timespec_Divide>:
  const struct timespec *lhs,
  const struct timespec *rhs,
  uint32_t              *ival_percentage,
  uint32_t              *fval_percentage
)
{
   4a1cc:	4e56 ffd8      	linkw %fp,#-40                                    	<== NOT EXECUTED
   4a1d0:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   4a1d4:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   4a1d8:	246e 000c      	moveal %fp@(12),%a2                               	<== 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;
  left  += lhs->tv_nsec;
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
   4a1dc:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
   4a1e2:	4bf9 0005 62e4 	lea 562e4 <__muldi3>,%a5                          	<== NOT EXECUTED
   4a1e8:	42a7           	clrl %sp@-                                        	<== 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;
  left  += lhs->tv_nsec;
   4a1ea:	2a28 0004      	movel %a0@(4),%d5                                 	<== 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;
   4a1ee:	2810           	movel %a0@,%d4                                    	<== NOT EXECUTED
  left  += lhs->tv_nsec;
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
   4a1f0:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   4a1f2:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   4a1f4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4a1f6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4a1f8:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
  right += rhs->tv_nsec;
   4a1fa:	262a 0004      	movel %a2@(4),%d3                                 	<== NOT EXECUTED
   4a1fe:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   4a200:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   4a202:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   4a204:	d182           	addxl %d2,%d0                                     	<== 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;
  left  += lhs->tv_nsec;
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
   4a206:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  right += rhs->tv_nsec;
   4a20c:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
   4a20e:	2841           	moveal %d1,%a4                                    	<== NOT EXECUTED

  if ( right == 0 ) {
   4a210:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4a212:	661a           	bnes 4a22e <_Timespec_Divide+0x62>                	<== NOT EXECUTED
   4a214:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4a216:	6616           	bnes 4a22e <_Timespec_Divide+0x62>                	<== NOT EXECUTED
    *ival_percentage = 0;
   4a218:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   4a21c:	4290           	clrl %a0@                                         	<== NOT EXECUTED
    *fval_percentage = 0;
   4a21e:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
  *fval_percentage = answer % 1000;
}
   4a222:	4cee 3cfc ffd8 	moveml %fp@(-40),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   4a228:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
  right += rhs->tv_nsec;

  if ( right == 0 ) {
    *ival_percentage = 0;
    *fval_percentage = 0;
   4a22a:	4290           	clrl %a0@                                         	<== NOT EXECUTED

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
  *fval_percentage = answer % 1000;
}
   4a22c:	4e75           	rts                                               	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   4a22e:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   4a230:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   4a232:	49c2           	extbl %d2                                         	<== 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;
   4a234:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   4a23a:	7a1b           	moveq #27,%d5                                     	<== 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;
   4a23c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4a23e:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4a240:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   4a242:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4a244:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4a246:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   4a248:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   4a24a:	d182           	addxl %d2,%d0                                     	<== NOT EXECUTED
   4a24c:	2801           	movel %d1,%d4                                     	<== NOT EXECUTED
   4a24e:	741e           	moveq #30,%d2                                     	<== NOT EXECUTED
   4a250:	e4ac           	lsrl %d2,%d4                                      	<== NOT EXECUTED
   4a252:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4a254:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
   4a256:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   4a258:	8484           	orl %d4,%d2                                       	<== NOT EXECUTED
   4a25a:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   4a25c:	2803           	movel %d3,%d4                                     	<== NOT EXECUTED
   4a25e:	2c02           	movel %d2,%d6                                     	<== NOT EXECUTED
   4a260:	eaac           	lsrl %d5,%d4                                      	<== NOT EXECUTED
   4a262:	2e03           	movel %d3,%d7                                     	<== NOT EXECUTED
   4a264:	eb8e           	lsll #5,%d6                                       	<== NOT EXECUTED
   4a266:	8c84           	orl %d4,%d6                                       	<== NOT EXECUTED
   4a268:	eb8f           	lsll #5,%d7                                       	<== NOT EXECUTED
   4a26a:	2806           	movel %d6,%d4                                     	<== NOT EXECUTED
   4a26c:	2a07           	movel %d7,%d5                                     	<== NOT EXECUTED
   4a26e:	9a83           	subl %d3,%d5                                      	<== NOT EXECUTED
   4a270:	9982           	subxl %d2,%d4                                     	<== NOT EXECUTED
   4a272:	da81           	addl %d1,%d5                                      	<== NOT EXECUTED
   4a274:	d980           	addxl %d0,%d4                                     	<== NOT EXECUTED
   4a276:	721e           	moveq #30,%d1                                     	<== NOT EXECUTED
   4a278:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4a27a:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   4a27c:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   4a27e:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   4a280:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   4a282:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   4a284:	e58b           	lsll #2,%d3                                       	<== 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;
   4a286:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   4a28c:	da83           	addl %d3,%d5                                      	<== NOT EXECUTED
   4a28e:	d982           	addxl %d2,%d4                                     	<== NOT EXECUTED
   4a290:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   4a292:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4a294:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   4a296:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   4a298:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   4a29a:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   4a29c:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   4a29e:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   4a2a0:	da83           	addl %d3,%d5                                      	<== NOT EXECUTED
   4a2a2:	d982           	addxl %d2,%d4                                     	<== NOT EXECUTED
   4a2a4:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4a2a6:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4a2a8:	741b           	moveq #27,%d2                                     	<== NOT EXECUTED
   4a2aa:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   4a2ac:	e4a8           	lsrl %d2,%d0                                      	<== NOT EXECUTED
   4a2ae:	eb8b           	lsll #5,%d3                                       	<== NOT EXECUTED
   4a2b0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a2b2:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   4a2b4:	eb8a           	lsll #5,%d2                                       	<== NOT EXECUTED
   4a2b6:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   4a2b8:	45f9 0005 634c 	lea 5634c <__udivdi3>,%a2                         	<== NOT EXECUTED
   4a2be:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a2c0:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4a2c2:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED

  *ival_percentage = answer / 1000;
   4a2c8:	4878 03e8      	pea 3e8 <FP_REGS_SAVED+0x3a8>                     	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   4a2cc:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4a2ce:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED

  *ival_percentage = answer / 1000;
   4a2d0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4a2d2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a2d4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4a2d6:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4a2d8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  *fval_percentage = answer % 1000;
   4a2de:	4878 03e8      	pea 3e8 <FP_REGS_SAVED+0x3a8>                     	<== NOT EXECUTED
   4a2e2:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
   4a2e4:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   4a2e8:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  *fval_percentage = answer % 1000;
   4a2ea:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a2ec:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a2ee:	4eb9 0005 6700 	jsr 56700 <__umoddi3>                             	<== NOT EXECUTED
   4a2f4:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   4a2f8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   4a2fe:	4cee 3cfc ffd8 	moveml %fp@(-40),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   4a304:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
  *fval_percentage = answer % 1000;
   4a306:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
}
   4a308:	4e75           	rts                                               	<== NOT EXECUTED
	...

00063d58 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   63d58:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   63d5c:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
  /*
   *  For math simplicity just convert the timespec to nanoseconds
   *  in a 64-bit integer.
   */
  t  = time->tv_sec;
  t *= TOD_NANOSECONDS_PER_SECOND;
   63d60:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   63d66:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  /*
   *  For math simplicity just convert the timespec to nanoseconds
   *  in a 64-bit integer.
   */
  t  = time->tv_sec;
  t *= TOD_NANOSECONDS_PER_SECOND;
   63d6a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   63d6c:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   63d6e:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   63d70:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   63d72:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   63d74:	4eb9 0007 e4e0 	jsr 7e4e0 <__muldi3>                              	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   63d7a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   63d80:	2eae 000c      	movel %fp@(12),%sp@                               	<== NOT EXECUTED
   *  For math simplicity just convert the timespec to nanoseconds
   *  in a 64-bit integer.
   */
  t  = time->tv_sec;
  t *= TOD_NANOSECONDS_PER_SECOND;
  t += time->tv_nsec;
   63d84:	262a 0004      	movel %a2@(4),%d3                                 	<== NOT EXECUTED
   63d88:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   63d8a:	49c2           	extbl %d2                                         	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   63d8c:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   63d8e:	d182           	addxl %d2,%d0                                     	<== NOT EXECUTED
   63d90:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   63d92:	47f9 0007 e5c4 	lea 7e5c4 <__udivdi3>,%a3                         	<== NOT EXECUTED
   63d98:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   63d9a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   63d9c:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   63d9e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   63da4:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   63daa:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   63dac:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   63dae:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   63db0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   63db2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   63db4:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   63db6:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
   63dbc:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   63dc2:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
   63dc6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   63dc8:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
   63dca:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   63dcc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   63dce:	4eb9 0007 e978 	jsr 7e978 <__umoddi3>                             	<== NOT EXECUTED
   63dd4:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
   63dd8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   63dde:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   63de4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   63de6:	4e75           	rts

00053a4c <_Timespec_From_ticks>:

void _Timespec_From_ticks(
  uint32_t         ticks,
  struct timespec *time
)
{
   53a4c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  uint32_t    usecs;

  usecs = ticks * _TOD_Microseconds_per_tick;
   53a50:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   53a54:	43f9 0006 6d6a 	lea 66d6a <_TOD_Microseconds_per_tick>,%a1        	<== NOT EXECUTED
   53a5a:	4c11 0800      	mulsl %a1@,%d0                                    	<== NOT EXECUTED

void _Timespec_From_ticks(
  uint32_t         ticks,
  struct timespec *time
)
{
   53a5e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   53a60:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  uint32_t    usecs;

  usecs = ticks * _TOD_Microseconds_per_tick;

  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;
   53a64:	243c 000f 4240 	movel #1000000,%d2                                	<== NOT EXECUTED
   53a6a:	4c42 0001      	remul %d2,%d1,%d0                                 	<== NOT EXECUTED
   53a6e:	4c42 0000      	remul %d2,%d0,%d0                                 	<== NOT EXECUTED
   53a72:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
   53a74:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   53a76:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   53a78:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   53a7a:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
   53a7c:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   53a7e:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
  uint32_t    usecs;

  usecs = ticks * _TOD_Microseconds_per_tick;

  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
   53a80:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   53a82:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   53a84:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  uint32_t    usecs;

  usecs = ticks * _TOD_Microseconds_per_tick;

  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
   53a86:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   53a8a:	4e75           	rts

0004a794 <_Timespec_Greater_than>:

bool _Timespec_Greater_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
   4a794:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a798:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4a79c:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  if ( lhs->tv_sec > rhs->tv_sec )
   4a7a0:	2211           	movel %a1@,%d1                                    	<== NOT EXECUTED
   4a7a2:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   4a7a4:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4a7a6:	6d18           	blts 4a7c0 <_Timespec_Greater_than+0x2c>          	<== NOT EXECUTED
    return TRUE;

  if ( lhs->tv_sec < rhs->tv_sec )
   4a7a8:	6e10           	bgts 4a7ba <_Timespec_Greater_than+0x26>          	<== NOT EXECUTED
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
   4a7aa:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
   4a7ae:	b1e9 0004      	cmpal %a1@(4),%a0                                 	<== NOT EXECUTED
   4a7b2:	5dc0           	slt %d0                                           	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   4a7b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( lhs->tv_sec < rhs->tv_sec )
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
   4a7b6:	4480           	negl %d0                                          	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   4a7b8:	4e75           	rts                                               	<== NOT EXECUTED
   4a7ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( lhs->tv_sec > rhs->tv_sec )
    return TRUE;

  if ( lhs->tv_sec < rhs->tv_sec )
   4a7bc:	4200           	clrb %d0                                          	<== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
    return TRUE;

  return FALSE;
}
   4a7be:	4e75           	rts                                               	<== NOT EXECUTED
   4a7c0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
bool _Timespec_Greater_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
  if ( lhs->tv_sec > rhs->tv_sec )
   4a7c2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
    return TRUE;

  return FALSE;
}
   4a7c4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00053a8c <_Timespec_Is_valid>:
#include <rtems/score/tod.h>

bool _Timespec_Is_valid(
  const struct timespec *time
)
{
   53a8c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   53a90:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( !time )
   53a94:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   53a96:	6718           	beqs 53ab0 <_Timespec_Is_valid+0x24>              	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_sec < 0 )
   53a98:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   53a9a:	6d14           	blts 53ab0 <_Timespec_Is_valid+0x24>              	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_nsec < 0 )
   53a9c:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
   53aa0:	6d0e           	blts 53ab0 <_Timespec_Is_valid+0x24>              	<== NOT EXECUTED

  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
    return FALSE;

  return TRUE;
}
   53aa2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_sec < 0 )
    return FALSE;

  if ( time->tv_nsec < 0 )
   53aa4:	0c80 3b9a c9ff 	cmpil #999999999,%d0                              	<== NOT EXECUTED
   53aaa:	53c0           	sls %d0                                           	<== NOT EXECUTED
   53aac:	4480           	negl %d0                                          	<== NOT EXECUTED

  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
    return FALSE;

  return TRUE;
}
   53aae:	4e75           	rts                                               	<== NOT EXECUTED
   53ab0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_sec < 0 )
    return FALSE;

  if ( time->tv_nsec < 0 )
   53ab2:	4200           	clrb %d0                                          	<== NOT EXECUTED

  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
    return FALSE;

  return TRUE;
}
   53ab4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a7c8 <_Timespec_Less_than>:

bool _Timespec_Less_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
   4a7c8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a7cc:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4a7d0:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  if ( lhs->tv_sec < rhs->tv_sec )
   4a7d4:	2211           	movel %a1@,%d1                                    	<== NOT EXECUTED
   4a7d6:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   4a7d8:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4a7da:	6e18           	bgts 4a7f4 <_Timespec_Less_than+0x2c>             	<== NOT EXECUTED
    return TRUE;

  if ( lhs->tv_sec > rhs->tv_sec )
   4a7dc:	6d10           	blts 4a7ee <_Timespec_Less_than+0x26>             	<== NOT EXECUTED
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec < rhs->tv_nsec )
   4a7de:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
   4a7e2:	b1e9 0004      	cmpal %a1@(4),%a0                                 	<== NOT EXECUTED
   4a7e6:	5ec0           	sgt %d0                                           	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   4a7e8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( lhs->tv_sec > rhs->tv_sec )
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec < rhs->tv_nsec )
   4a7ea:	4480           	negl %d0                                          	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   4a7ec:	4e75           	rts                                               	<== NOT EXECUTED
   4a7ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( lhs->tv_sec < rhs->tv_sec )
    return TRUE;

  if ( lhs->tv_sec > rhs->tv_sec )
   4a7f0:	4200           	clrb %d0                                          	<== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec < rhs->tv_nsec )
    return TRUE;

  return FALSE;
}
   4a7f2:	4e75           	rts                                               	<== NOT EXECUTED
   4a7f4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
bool _Timespec_Less_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
  if ( lhs->tv_sec < rhs->tv_sec )
   4a7f6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec < rhs->tv_nsec )
    return TRUE;

  return FALSE;
}
   4a7f8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048bec <_Timespec_Subtract>:
void _Timespec_Subtract(
  const struct timespec *start,
  const struct timespec *end,
  struct timespec       *result
)
{
   48bec:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48bf0:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   48bf4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48bf6:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED

  if (end->tv_nsec < start->tv_nsec) {
   48bfa:	2029 0004      	movel %a1@(4),%d0                                 	<== NOT EXECUTED
void _Timespec_Subtract(
  const struct timespec *start,
  const struct timespec *end,
  struct timespec       *result
)
{
   48bfe:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED

  if (end->tv_nsec < start->tv_nsec) {
   48c02:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   48c06:	6e18           	bgts 48c20 <_Timespec_Subtract+0x34>              	<== NOT EXECUTED
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
    result->tv_nsec =
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
  } else {
    result->tv_sec  = end->tv_sec - start->tv_sec;
   48c08:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   48c0a:	9091           	subl %a1@,%d0                                     	<== NOT EXECUTED
   48c0c:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
    result->tv_nsec = end->tv_nsec - start->tv_nsec;
   48c0e:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
   48c12:	90a9 0004      	subl %a1@(4),%d0                                  	<== NOT EXECUTED
   48c16:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
  }
}
   48c1a:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   48c1c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48c1e:	4e75           	rts                                               	<== NOT EXECUTED
  struct timespec       *result
)
{

  if (end->tv_nsec < start->tv_nsec) {
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   48c20:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
    result->tv_nsec =
   48c22:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
  struct timespec       *result
)
{

  if (end->tv_nsec < start->tv_nsec) {
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   48c26:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
    result->tv_nsec =
   48c28:	0681 3b9a ca00 	addil #1000000000,%d1                             	<== NOT EXECUTED
  struct timespec       *result
)
{

  if (end->tv_nsec < start->tv_nsec) {
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   48c2e:	9091           	subl %a1@,%d0                                     	<== NOT EXECUTED
    result->tv_nsec =
   48c30:	92a9 0004      	subl %a1@(4),%d1                                  	<== NOT EXECUTED
  struct timespec       *result
)
{

  if (end->tv_nsec < start->tv_nsec) {
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   48c34:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
    result->tv_nsec =
   48c36:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
  } else {
    result->tv_sec  = end->tv_sec - start->tv_sec;
    result->tv_nsec = end->tv_nsec - start->tv_nsec;
  }
}
   48c3a:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   48c3c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48c3e:	4e75           	rts

00053ab8 <_Timespec_To_ticks>:
 */

uint32_t _Timespec_To_ticks(
  const struct timespec *time
)
{
   53ab8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   53abc:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   53ac0:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
  uint32_t  ticks;

  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
   53ac4:	2610           	movel %a0@,%d3                                    	<== NOT EXECUTED
   53ac6:	6738           	beqs 53b00 <_Timespec_To_ticks+0x48>              	<== NOT EXECUTED
   53ac8:	2428 0004      	movel %a0@(4),%d2                                 	<== NOT EXECUTED
    return 0;

  ticks  = time->tv_sec * TOD_TICKS_PER_SECOND;
   53acc:	2039 0006 6d6a 	movel 66d6a <_TOD_Microseconds_per_tick>,%d0      	<== NOT EXECUTED
   53ad2:	223c 000f 4240 	movel #1000000,%d1                                	<== NOT EXECUTED
   53ad8:	4c40 1001      	remul %d0,%d1,%d1                                 	<== NOT EXECUTED
   53adc:	4c03 1800      	mulsl %d3,%d1                                     	<== NOT EXECUTED

  ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) /
   53ae0:	283c 0000 03e8 	movel #1000,%d4                                   	<== NOT EXECUTED
   53ae6:	4c44 2002      	remul %d4,%d2,%d2                                 	<== NOT EXECUTED
   53aea:	4c40 2002      	remul %d0,%d2,%d2                                 	<== NOT EXECUTED
   53aee:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   53af0:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
             _TOD_Microseconds_per_tick;

  if (ticks)
   53af2:	6604           	bnes 53af8 <_Timespec_To_ticks+0x40>              	<== NOT EXECUTED
   53af4:	103c 0001      	moveb #1,%d0                                      	<== NOT EXECUTED
    return ticks;

  return 1;
}
   53af8:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   53afc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53afe:	4e75           	rts                                               	<== NOT EXECUTED
  const struct timespec *time
)
{
  uint32_t  ticks;

  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
   53b00:	2428 0004      	movel %a0@(4),%d2                                 	<== NOT EXECUTED
   53b04:	66c6           	bnes 53acc <_Timespec_To_ticks+0x14>              	<== NOT EXECUTED

  if (ticks)
    return ticks;

  return 1;
}
   53b06:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   53b0a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  const struct timespec *time
)
{
  uint32_t  ticks;

  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
   53b0c:	4280           	clrl %d0                                          	<== NOT EXECUTED

  if (ticks)
    return ticks;

  return 1;
}
   53b0e:	4e75           	rts

0004bb34 <_User_extensions_Add_API_set>:
 */

void _User_extensions_Add_API_set (
  User_extensions_Control *the_extension
)
{
   4bb34:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4bb38:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4bb3a:	47f9 0004 66d8 	lea 466d8 <_Chain_Append>,%a3                     	<== NOT EXECUTED
 */

void _User_extensions_Add_API_set (
  User_extensions_Control *the_extension
)
{
   4bb40:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4bb42:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4bb46:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4bb48:	4879 0005 88f2 	pea 588f2 <_User_extensions_List>                 	<== NOT EXECUTED
   4bb4e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

  /*
   *  If a switch handler is present, append it to the switch chain.
   */

  if ( the_extension->Callouts.thread_switch != NULL ) {
   4bb50:	202a 0024      	movel %a2@(36),%d0                                	<== NOT EXECUTED
   4bb54:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4bb56:	6712           	beqs 4bb6a <_User_extensions_Add_API_set+0x36>    	<== NOT EXECUTED
    the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
    _Chain_Append(
   4bb58:	486a 0008      	pea %a2@(8)                                       	<== NOT EXECUTED
   4bb5c:	4879 0005 8758 	pea 58758 <_User_extensions_Switches_list>        	<== NOT EXECUTED
  /*
   *  If a switch handler is present, append it to the switch chain.
   */

  if ( the_extension->Callouts.thread_switch != NULL ) {
    the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
   4bb62:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
    _Chain_Append(
   4bb66:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4bb68:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      &_User_extensions_Switches_list, &the_extension->Switch.Node );
  }
}
   4bb6a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4bb6e:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4bb72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bb74:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004bb78 <_User_extensions_Add_set>:

void _User_extensions_Add_set (
  User_extensions_Control *the_extension,
  User_extensions_Table   *extension_table
)
{
   4bb78:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4bb7c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4bb7e:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4bb82:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4bb84:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  the_extension->Callouts = *extension_table;
   4bb88:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   4bb8a:	2758 0014      	movel %a0@+,%a3@(20)                              	<== NOT EXECUTED
   4bb8e:	2758 0018      	movel %a0@+,%a3@(24)                              	<== NOT EXECUTED
   4bb92:	2758 001c      	movel %a0@+,%a3@(28)                              	<== NOT EXECUTED
   4bb96:	2758 0020      	movel %a0@+,%a3@(32)                              	<== NOT EXECUTED
   4bb9a:	2758 0024      	movel %a0@+,%a3@(36)                              	<== NOT EXECUTED
   4bb9e:	2758 0028      	movel %a0@+,%a3@(40)                              	<== NOT EXECUTED
   4bba2:	2758 002c      	movel %a0@+,%a3@(44)                              	<== NOT EXECUTED
   4bba6:	2750 0030      	movel %a0@,%a3@(48)                               	<== NOT EXECUTED

  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4bbaa:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4bbac:	4879 0005 88f2 	pea 588f2 <_User_extensions_List>                 	<== NOT EXECUTED
   4bbb2:	4eb9 0004 66d8 	jsr 466d8 <_Chain_Append>                         	<== NOT EXECUTED

  /*
   * If a switch handler is present, append it to the switch chain.
   */

  if ( extension_table->thread_switch != NULL ) {
   4bbb8:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4bbbc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4bbbe:	6726           	beqs 4bbe6 <_User_extensions_Add_set+0x6e>        	<== NOT EXECUTED
    the_extension->Switch.thread_switch = extension_table->thread_switch;
    _Chain_Append(
   4bbc0:	220b           	movel %a3,%d1                                     	<== NOT EXECUTED
   4bbc2:	5081           	addql #8,%d1                                      	<== NOT EXECUTED
   4bbc4:	2d41 000c      	movel %d1,%fp@(12)                                	<== NOT EXECUTED
   4bbc8:	223c 0005 8758 	movel #362328,%d1                                 	<== NOT EXECUTED
   4bbce:	2d41 0008      	movel %d1,%fp@(8)                                 	<== NOT EXECUTED
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4bbd2:	246e fff8      	moveal %fp@(-8),%a2                               	<== 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;
   4bbd6:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
    _Chain_Append(
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4bbda:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4bbde:	4e5e           	unlk %fp                                          	<== 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(
   4bbe0:	4ef9 0004 66d8 	jmp 466d8 <_Chain_Append>                         	<== NOT EXECUTED
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4bbe6:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4bbea:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4bbee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4bbf0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048d6a <_User_extensions_Fatal>:
void _User_extensions_Fatal (
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   48d6a:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   48d6e:	48d7 041c      	moveml %d2-%d4/%a2,%sp@                           	<== NOT EXECUTED
   48d72:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   48d76:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   48d7a:	2479 0005 88fa 	moveal 588fa <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
void _User_extensions_Fatal (
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   48d80:	102e 000f      	moveb %fp@(15),%d0                                	<== 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 ) ;
   48d84:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48d8a:	6726           	beqs 48db2 <_User_extensions_Fatal+0x48>          	<== 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 );
   48d8c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   48d8e:	1400           	moveb %d0,%d2                                     	<== 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 )
   48d90:	206a 0030      	moveal %a2@(48),%a0                               	<== NOT EXECUTED
   48d94:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48d96:	670e           	beqs 48da6 <_User_extensions_Fatal+0x3c>          	<== NOT EXECUTED
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
   48d98:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   48d9a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48d9c:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   48d9e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48da0:	dffc 0000 000c 	addal #12,%sp                                     	<== 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 ) {
   48da6:	246a 0004      	moveal %a2@(4),%a2                                	<== 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 ) ;
   48daa:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48db0:	66de           	bnes 48d90 <_User_extensions_Fatal+0x26>          	<== 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 );
  }
}
   48db2:	4cee 041c fff0 	moveml %fp@(-16),%d2-%d4/%a2                      	<== NOT EXECUTED
   48db8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48dba:	4e75           	rts

00048c40 <_User_extensions_Handler_initialization>:

void _User_extensions_Handler_initialization (
  uint32_t                number_of_extensions,
  User_extensions_Table  *initial_extensions
)
{
   48c40:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   48c44:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48c48:	203c 0005 88f6 	movel #362742,%d0                                 	<== NOT EXECUTED
   48c4e:	23c0 0005 88f2 	movel %d0,588f2 <_User_extensions_List>           	<== NOT EXECUTED
   48c54:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   48c58:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   48c5c:	203c 0005 88f2 	movel #362738,%d0                                 	<== NOT EXECUTED
   48c62:	23c0 0005 88fa 	movel %d0,588fa <_User_extensions_List+0x8>       	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48c68:	203c 0005 875c 	movel #362332,%d0                                 	<== NOT EXECUTED
   48c6e:	23c0 0005 8758 	movel %d0,58758 <_User_extensions_Switches_list>  	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   48c74:	203c 0005 8758 	movel #362328,%d0                                 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   48c7a:	42b9 0005 88f6 	clrl 588f6 <_User_extensions_List+0x4>            	<== NOT EXECUTED
   48c80:	42b9 0005 875c 	clrl 5875c <_User_extensions_Switches_list+0x4>   	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   48c86:	23c0 0005 8760 	movel %d0,58760 <_User_extensions_Switches_list+0x8>	<== NOT EXECUTED
  uint32_t                 i;

  _Chain_Initialize_empty( &_User_extensions_List );
  _Chain_Initialize_empty( &_User_extensions_Switches_list );

  if ( initial_extensions ) {
   48c8c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   48c8e:	6750           	beqs 48ce0 <_User_extensions_Handler_initialization+0xa0>	<== NOT EXECUTED
    extension = (User_extensions_Control *)
   48c90:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48c92:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   48c94:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   48c96:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   48c98:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   48c9a:	d485           	addl %d5,%d2                                      	<== NOT EXECUTED
   48c9c:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   48c9e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48ca0:	4eb9 0004 9170 	jsr 49170 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        number_of_extensions * sizeof( User_extensions_Control )
      );

    memset (
   48ca6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

  _Chain_Initialize_empty( &_User_extensions_List );
  _Chain_Initialize_empty( &_User_extensions_Switches_list );

  if ( initial_extensions ) {
    extension = (User_extensions_Control *)
   48ca8:	2800           	movel %d0,%d4                                     	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        number_of_extensions * sizeof( User_extensions_Control )
      );

    memset (
   48caa:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   48cac:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48cae:	4eb9 0004 ce28 	jsr 4ce28 <memset>                                	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   48cb4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   48cba:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   48cbc:	6722           	beqs 48ce0 <_User_extensions_Handler_initialization+0xa0>	<== NOT EXECUTED
   48cbe:	4282           	clrl %d2                                          	<== NOT EXECUTED
   48cc0:	45f9 0004 bb78 	lea 4bb78 <_User_extensions_Add_set>,%a2          	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
   48cc6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   48cc8:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   48cca:	0683 0000 0020 	addil #32,%d3                                     	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
   48cd0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   48cd2:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   48cd4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
      extension++;
   48cd6:	0684 0000 0034 	addil #52,%d4                                     	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   48cdc:	b485           	cmpl %d5,%d2                                      	<== NOT EXECUTED
   48cde:	65e6           	bcss 48cc6 <_User_extensions_Handler_initialization+0x86>	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
      extension++;
    }
  }
}
   48ce0:	4cee 043c ffec 	moveml %fp@(-20),%d2-%d5/%a2                      	<== NOT EXECUTED
   48ce6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48ce8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e698 <_User_extensions_Remove_set>:
 */

void _User_extensions_Remove_set (
  User_extensions_Control  *the_extension
)
{
   4e698:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4e69c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4e69e:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _Chain_Extract( &the_extension->Node );
   4e6a2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4e6a4:	4eb9 0005 2cc4 	jsr 52cc4 <_Chain_Extract>                        	<== NOT EXECUTED

  /*
   * If a switch handler is present, remove it.
   */

  if ( the_extension->Callouts.thread_switch != NULL )
   4e6aa:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4e6ac:	4aaa 0024      	tstl %a2@(36)                                     	<== NOT EXECUTED
   4e6b0:	6712           	beqs 4e6c4 <_User_extensions_Remove_set+0x2c>     	<== NOT EXECUTED
    _Chain_Extract( &the_extension->Switch.Node );
   4e6b2:	508a           	addql #8,%a2                                      	<== NOT EXECUTED
   4e6b4:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
}
   4e6b8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4e6bc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  /*
   * If a switch handler is present, remove it.
   */

  if ( the_extension->Callouts.thread_switch != NULL )
    _Chain_Extract( &the_extension->Switch.Node );
   4e6be:	4ef9 0005 2cc4 	jmp 52cc4 <_Chain_Extract>                        	<== NOT EXECUTED
}
   4e6c4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4e6c8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e6ca:	4e75           	rts

00048cec <_User_extensions_Thread_begin>:
 */

void _User_extensions_Thread_begin (
  Thread_Control *executing
)
{
   48cec:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48cf0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   48cf2:	2479 0005 88f2 	moveal 588f2 <_User_extensions_List>,%a2          	<== NOT EXECUTED
 */

void _User_extensions_Thread_begin (
  Thread_Control *executing
)
{
   48cf8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48cfa:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   48cfe:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48d04:	6718           	beqs 48d1e <_User_extensions_Thread_begin+0x32>   	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_begin != NULL )
   48d06:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   48d0a:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48d0c:	6706           	beqs 48d14 <_User_extensions_Thread_begin+0x28>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_begin)( executing );
   48d0e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48d10:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48d12:	588f           	addql #4,%sp                                      	<== 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 ) {
   48d14:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   48d16:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48d1c:	66e8           	bnes 48d06 <_User_extensions_Thread_begin+0x1a>   	<== NOT EXECUTED
    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_begin != NULL )
      (*the_extension->Callouts.thread_begin)( executing );
  }
}
   48d1e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48d22:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48d26:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48d28:	4e75           	rts

00048dbc <_User_extensions_Thread_create>:
 */

bool _User_extensions_Thread_create (
  Thread_Control *the_thread
)
{
   48dbc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48dc0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;
  bool                     status;

  for ( the_node = _User_extensions_List.first ;
   48dc2:	2479 0005 88f2 	moveal 588f2 <_User_extensions_List>,%a2          	<== NOT EXECUTED
 */

bool _User_extensions_Thread_create (
  Thread_Control *the_thread
)
{
   48dc8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48dca:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   48dce:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48dd4:	6722           	beqs 48df8 <_User_extensions_Thread_create+0x3c>  	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_create != NULL ) {
   48dd6:	206a 0014      	moveal %a2@(20),%a0                               	<== NOT EXECUTED
   48dda:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48ddc:	6710           	beqs 48dee <_User_extensions_Thread_create+0x32>  	<== NOT EXECUTED
      status = (*the_extension->Callouts.thread_create)(
   48dde:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48de0:	2f39 0005 8812 	movel 58812 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   48de6:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
        _Thread_Executing,
        the_thread
      );
      if ( !status )
   48de8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   48dea:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   48dec:	670c           	beqs 48dfa <_User_extensions_Thread_create+0x3e>  	<== NOT EXECUTED
  User_extensions_Control *the_extension;
  bool                     status;

  for ( the_node = _User_extensions_List.first ;
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
        the_node = the_node->next ) {
   48dee:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   48df0:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48df6:	66de           	bnes 48dd6 <_User_extensions_Thread_create+0x1a>  	<== NOT EXECUTED
   48df8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        return FALSE;
    }
  }

  return TRUE;
}
   48dfa:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48dfe:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48e02:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48e04:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048e08 <_User_extensions_Thread_delete>:
 */

void _User_extensions_Thread_delete (
  Thread_Control *the_thread
)
{
   48e08:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48e0c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   48e0e:	2479 0005 88fa 	moveal 588fa <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
 */

void _User_extensions_Thread_delete (
  Thread_Control *the_thread
)
{
   48e14:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48e16:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   48e1a:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48e20:	6720           	beqs 48e42 <_User_extensions_Thread_delete+0x3a>  	<== NOT EXECUTED
        the_node = the_node->previous ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_delete != NULL )
   48e22:	206a 0020      	moveal %a2@(32),%a0                               	<== NOT EXECUTED
   48e26:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48e28:	670c           	beqs 48e36 <_User_extensions_Thread_delete+0x2e>  	<== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(
   48e2a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48e2c:	2f39 0005 8812 	movel 58812 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   48e32:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48e34:	508f           	addql #8,%sp                                      	<== 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 ) {
   48e36:	246a 0004      	moveal %a2@(4),%a2                                	<== 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 ) ;
   48e3a:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48e40:	66e0           	bnes 48e22 <_User_extensions_Thread_delete+0x1a>  	<== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(
        _Thread_Executing,
        the_thread
      );
  }
}
   48e42:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48e46:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48e4a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48e4c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048d2a <_User_extensions_Thread_exitted>:
 */

void _User_extensions_Thread_exitted (
  Thread_Control *executing
)
{
   48d2a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48d2e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   48d30:	2479 0005 88fa 	moveal 588fa <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
 */

void _User_extensions_Thread_exitted (
  Thread_Control *executing
)
{
   48d36:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48d38:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   48d3c:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48d42:	671a           	beqs 48d5e <_User_extensions_Thread_exitted+0x34> 	<== NOT EXECUTED
        the_node = the_node->previous ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_exitted != NULL )
   48d44:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   48d48:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48d4a:	6706           	beqs 48d52 <_User_extensions_Thread_exitted+0x28> 	<== NOT EXECUTED
      (*the_extension->Callouts.thread_exitted)( executing );
   48d4c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48d4e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48d50:	588f           	addql #4,%sp                                      	<== 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 ) {
   48d52:	246a 0004      	moveal %a2@(4),%a2                                	<== 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 ) ;
   48d56:	b5fc 0005 88f2 	cmpal #362738,%a2                                 	<== NOT EXECUTED
   48d5c:	66e6           	bnes 48d44 <_User_extensions_Thread_exitted+0x1a> 	<== NOT EXECUTED
    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_exitted != NULL )
      (*the_extension->Callouts.thread_exitted)( executing );
  }
}
   48d5e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48d62:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48d66:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48d68:	4e75           	rts

00049848 <_User_extensions_Thread_restart>:
 */

void _User_extensions_Thread_restart (
  Thread_Control *the_thread
)
{
   49848:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4984c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   4984e:	2479 0005 a42a 	moveal 5a42a <_User_extensions_List>,%a2          	<== NOT EXECUTED
 */

void _User_extensions_Thread_restart (
  Thread_Control *the_thread
)
{
   49854:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   49856:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   4985a:	b5fc 0005 a42e 	cmpal #369710,%a2                                 	<== NOT EXECUTED
   49860:	671e           	beqs 49880 <_User_extensions_Thread_restart+0x38> 	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_restart != NULL )
   49862:	206a 001c      	moveal %a2@(28),%a0                               	<== NOT EXECUTED
   49866:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   49868:	670c           	beqs 49876 <_User_extensions_Thread_restart+0x2e> 	<== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(
   4986a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4986c:	2f39 0005 a34a 	movel 5a34a <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   49872:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   49874:	508f           	addql #8,%sp                                      	<== 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 ) {
   49876:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   49878:	b5fc 0005 a42e 	cmpal #369710,%a2                                 	<== NOT EXECUTED
   4987e:	66e2           	bnes 49862 <_User_extensions_Thread_restart+0x1a> 	<== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(
        _Thread_Executing,
        the_thread
      );
  }
}
   49880:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   49884:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   49888:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4988a:	4e75           	rts

00048e50 <_User_extensions_Thread_start>:
 */

void _User_extensions_Thread_start (
  Thread_Control *the_thread
)
{
   48e50:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48e54:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   48e56:	2479 0005 88f2 	moveal 588f2 <_User_extensions_List>,%a2          	<== NOT EXECUTED
 */

void _User_extensions_Thread_start (
  Thread_Control *the_thread
)
{
   48e5c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48e5e:	242e 0008      	movel %fp@(8),%d2                                 	<== 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 ) ;
   48e62:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48e68:	671e           	beqs 48e88 <_User_extensions_Thread_start+0x38>   	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_start != NULL )
   48e6a:	206a 0018      	moveal %a2@(24),%a0                               	<== NOT EXECUTED
   48e6e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48e70:	670c           	beqs 48e7e <_User_extensions_Thread_start+0x2e>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_start)(
   48e72:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48e74:	2f39 0005 8812 	movel 58812 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   48e7a:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48e7c:	508f           	addql #8,%sp                                      	<== 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 ) {
   48e7e:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   48e80:	b5fc 0005 88f6 	cmpal #362742,%a2                                 	<== NOT EXECUTED
   48e86:	66e2           	bnes 48e6a <_User_extensions_Thread_start+0x1a>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_start)(
        _Thread_Executing,
        the_thread
      );
  }
}
   48e88:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   48e8c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48e90:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48e92:	4e75           	rts

00048e94 <_User_extensions_Thread_switch>:
 */
void _User_extensions_Thread_switch (
  Thread_Control *executing,
  Thread_Control *heir
)
{
   48e94:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   48e98:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   48e9c:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   48ea0:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Chain_Node                     *the_node;
  User_extensions_Switch_control *the_extension_switch;

  for ( the_node = _User_extensions_Switches_list.first ;
   48ea4:	2479 0005 8758 	moveal 58758 <_User_extensions_Switches_list>,%a2 	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
   48eaa:	b5fc 0005 875c 	cmpal #362332,%a2                                 	<== NOT EXECUTED
   48eb0:	6716           	beqs 48ec8 <_User_extensions_Thread_switch+0x34>  	<== NOT EXECUTED
        the_node = the_node->next ) {

    the_extension_switch = (User_extensions_Switch_control *) the_node;

    (*the_extension_switch->thread_switch)( executing, heir );
   48eb2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48eb4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   48eb6:	206a 0008      	moveal %a2@(8),%a0                                	<== NOT EXECUTED
   48eba:	4e90           	jsr %a0@                                          	<== 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 ) {
   48ebc:	2452           	moveal %a2@,%a2                                   	<== 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 ) ;
   48ebe:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   48ec0:	b5fc 0005 875c 	cmpal #362332,%a2                                 	<== NOT EXECUTED
   48ec6:	66ea           	bnes 48eb2 <_User_extensions_Thread_switch+0x1e>  	<== NOT EXECUTED

    the_extension_switch = (User_extensions_Switch_control *) the_node;

    (*the_extension_switch->thread_switch)( executing, heir );
  }
}
   48ec8:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   48ece:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48ed0:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a670 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
  Chain_Control               *header,
  Watchdog_Adjust_directions   direction,
  Watchdog_Interval            units
)
{
   4a670:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4a674:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4a678:	327c 0700      	moveaw #1792,%a1                                  	<== NOT EXECUTED
void _Watchdog_Adjust(
  Chain_Control               *header,
  Watchdog_Adjust_directions   direction,
  Watchdog_Interval            units
)
{
   4a67c:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4a680:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4a684:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   4a686:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a688:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a68a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   4a68c:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   4a68e:	205a           	moveal %a2@+,%a0                                  	<== NOT EXECUTED
   *       hence the compiler must not assume *header to remain
   *       unmodified across that call.
   *
   *       Till Straumann, 7/2003
   */
  if ( !_Chain_Is_empty( header ) ) {
   4a690:	b5c8           	cmpal %a0,%a2                                     	<== NOT EXECUTED
   4a692:	674c           	beqs 4a6e0 <_Watchdog_Adjust+0x70>                	<== NOT EXECUTED
    switch ( direction ) {
   4a694:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   4a698:	6652           	bnes 4a6ec <_Watchdog_Adjust+0x7c>                	<== NOT EXECUTED
      case WATCHDOG_BACKWARD:
        _Watchdog_First( header )->delta_interval += units;
        break;
      case WATCHDOG_FORWARD:
        while ( units ) {
   4a69a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4a69c:	6742           	beqs 4a6e0 <_Watchdog_Adjust+0x70>                	<== NOT EXECUTED
          if ( units < _Watchdog_First( header )->delta_interval ) {
   4a69e:	2628 0010      	movel %a0@(16),%d3                                	<== NOT EXECUTED
   4a6a2:	b682           	cmpl %d2,%d3                                      	<== NOT EXECUTED
   4a6a4:	6234           	bhis 4a6da <_Watchdog_Adjust+0x6a>                	<== NOT EXECUTED

			_ISR_Enable( level );

            _Watchdog_Tickle( header );

			_ISR_Disable( level );
   4a6a6:	2809           	movel %a1,%d4                                     	<== NOT EXECUTED
   4a6a8:	49f9 0004 a8f0 	lea 4a8f0 <_Watchdog_Tickle>,%a4                  	<== NOT EXECUTED
          if ( units < _Watchdog_First( header )->delta_interval ) {
            _Watchdog_First( header )->delta_interval -= units;
            break;
          } else {
            units -= _Watchdog_First( header )->delta_interval;
            _Watchdog_First( header )->delta_interval = 1;
   4a6ae:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4a6b0:	2140 0010      	movel %d0,%a0@(16)                                	<== NOT EXECUTED

			_ISR_Enable( level );
   4a6b4:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

            _Watchdog_Tickle( header );
   4a6b6:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4a6b8:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

			_ISR_Disable( level );
   4a6ba:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   4a6bc:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a6be:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a6c0:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4a6c2:	2013           	movel %a3@,%d0                                    	<== 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;
   4a6c4:	9483           	subl %d3,%d2                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
  Chain_Control *header
)
{

  return ( (Watchdog_Control *) header->first );
   4a6c6:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

            _Watchdog_Tickle( header );

			_ISR_Disable( level );

            if ( _Chain_Is_empty( header ) )
   4a6c8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4a6ca:	b08a           	cmpl %a2,%d0                                      	<== NOT EXECUTED
   4a6cc:	6712           	beqs 4a6e0 <_Watchdog_Adjust+0x70>                	<== NOT EXECUTED
    switch ( direction ) {
      case WATCHDOG_BACKWARD:
        _Watchdog_First( header )->delta_interval += units;
        break;
      case WATCHDOG_FORWARD:
        while ( units ) {
   4a6ce:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4a6d0:	670e           	beqs 4a6e0 <_Watchdog_Adjust+0x70>                	<== NOT EXECUTED
          if ( units < _Watchdog_First( header )->delta_interval ) {
   4a6d2:	2628 0010      	movel %a0@(16),%d3                                	<== NOT EXECUTED
   4a6d6:	b483           	cmpl %d3,%d2                                      	<== NOT EXECUTED
   4a6d8:	64d4           	bccs 4a6ae <_Watchdog_Adjust+0x3e>                	<== NOT EXECUTED
            _Watchdog_First( header )->delta_interval -= units;
   4a6da:	9682           	subl %d2,%d3                                      	<== NOT EXECUTED
   4a6dc:	2143 0010      	movel %d3,%a0@(16)                                	<== NOT EXECUTED
        }
        break;
    }
  }

  _ISR_Enable( level );
   4a6e0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

}
   4a6e2:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   4a6e8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a6ea:	4e75           	rts                                               	<== NOT EXECUTED
   *       unmodified across that call.
   *
   *       Till Straumann, 7/2003
   */
  if ( !_Chain_Is_empty( header ) ) {
    switch ( direction ) {
   4a6ec:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4a6ee:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   4a6f2:	66ec           	bnes 4a6e0 <_Watchdog_Adjust+0x70>                	<== NOT EXECUTED
      case WATCHDOG_BACKWARD:
        _Watchdog_First( header )->delta_interval += units;
   4a6f4:	d5a8 0010      	addl %d2,%a0@(16)                                 	<== NOT EXECUTED
        }
        break;
    }
  }

  _ISR_Enable( level );
   4a6f8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

}
   4a6fa:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   4a700:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a702:	4e75           	rts

00057788 <_Watchdog_Adjust_to_chain>:
  Chain_Control               *header,
  Watchdog_Interval            units_arg,
  Chain_Control               *to_fire

)
{
   57788:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   5778c:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   57790:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   57794:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   57798:	286e 0010      	moveal %fp@(16),%a4                               	<== NOT EXECUTED
  Watchdog_Interval  units = units_arg;
  ISR_Level          level;
  Chain_Node        *node;

  if ( !units ) {
   5779c:	6766           	beqs 57804 <_Watchdog_Adjust_to_chain+0x7c>       	<== NOT EXECUTED
    return;
  }
  _ISR_Disable( level );
   5779e:	307c 0700      	moveaw #1792,%a0                                  	<== NOT EXECUTED
   577a2:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   577a4:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   577a6:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   577a8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   577aa:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   577ac:	225a           	moveal %a2@+,%a1                                  	<== NOT EXECUTED

  if ( !_Chain_Is_empty( header ) ) {
   577ae:	b5c9           	cmpal %a1,%a2                                     	<== NOT EXECUTED
   577b0:	6750           	beqs 57802 <_Watchdog_Adjust_to_chain+0x7a>       	<== NOT EXECUTED
   577b2:	2629 0010      	movel %a1@(16),%d3                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   577b6:	240c           	movel %a4,%d2                                     	<== NOT EXECUTED

        do {
          node = _Chain_Get_unprotected( header );
          _Chain_Append_unprotected( to_fire, node );

	  _ISR_Flash( level );
   577b8:	2a08           	movel %a0,%d5                                     	<== NOT EXECUTED
   577ba:	5882           	addql #4,%d2                                      	<== NOT EXECUTED
  }
  _ISR_Disable( level );

  if ( !_Chain_Is_empty( header ) ) {
    while ( units ) {
      if ( units < _Watchdog_First( header )->delta_interval ) {
   577bc:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   577be:	653c           	bcss 577fc <_Watchdog_Adjust_to_chain+0x74>       	<== NOT EXECUTED
	_Watchdog_First( header )->delta_interval -= units;
	break;
      } else {
	units -= _Watchdog_First( header )->delta_interval;
	_Watchdog_First( header )->delta_interval = 0;
   577c0:	42a9 0010      	clrl %a1@(16)                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   577c4:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   577c6:	6744           	beqs 5780c <_Watchdog_Adjust_to_chain+0x84>       	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   577c8:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   577ca:	2688           	movel %a0,%a3@                                    	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   577cc:	214b 0004      	movel %a3,%a0@(4)                                 	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   577d0:	2282           	movel %d2,%a1@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   577d2:	206c 0008      	moveal %a4@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   577d6:	2949 0008      	movel %a1,%a4@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   577da:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
   577de:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED

        do {
          node = _Chain_Get_unprotected( header );
          _Chain_Append_unprotected( to_fire, node );

	  _ISR_Flash( level );
   577e0:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   577e2:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   577e4:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   577e6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   577e8:	2253           	moveal %a3@,%a1                                   	<== NOT EXECUTED

        } while ( !_Chain_Is_empty( header ) &&
                  _Watchdog_First( header )->delta_interval == 0 );
   577ea:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   577ec:	6714           	beqs 57802 <_Watchdog_Adjust_to_chain+0x7a>       	<== NOT EXECUTED
   577ee:	2029 0010      	movel %a1@(16),%d0                                	<== NOT EXECUTED
   577f2:	67d0           	beqs 577c4 <_Watchdog_Adjust_to_chain+0x3c>       	<== 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;
   577f4:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
    return;
  }
  _ISR_Disable( level );

  if ( !_Chain_Is_empty( header ) ) {
    while ( units ) {
   577f6:	670a           	beqs 57802 <_Watchdog_Adjust_to_chain+0x7a>       	<== NOT EXECUTED
   577f8:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
   577fa:	60c0           	bras 577bc <_Watchdog_Adjust_to_chain+0x34>       	<== NOT EXECUTED
      if ( units < _Watchdog_First( header )->delta_interval ) {
	_Watchdog_First( header )->delta_interval -= units;
   577fc:	9681           	subl %d1,%d3                                      	<== NOT EXECUTED
   577fe:	2343 0010      	movel %d3,%a1@(16)                                	<== NOT EXECUTED
	  break;
      }
    }

  }
  _ISR_Enable( level );
   57802:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   57804:	4cd7 1c3c      	moveml %sp@,%d2-%d5/%a2-%a4                       	<== NOT EXECUTED
   57808:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5780a:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   5780c:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   5780e:	60c0           	bras 577d0 <_Watchdog_Adjust_to_chain+0x48>       	<== NOT EXECUTED

00048fd0 <_Watchdog_Handler_initialization>:
 *  Output parameters: NONE
 */

void _Watchdog_Handler_initialization( void )
{
  _Watchdog_Sync_count = 0;
   48fd0:	42b9 0005 8898 	clrl 58898 <_Watchdog_Sync_count>                 	<== NOT EXECUTED
 *
 *  Output parameters: NONE
 */

void _Watchdog_Handler_initialization( void )
{
   48fd6:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Watchdog_Sync_count = 0;
  _Watchdog_Sync_level = 0;
   48fda:	42b9 0005 880e 	clrl 5880e <_Watchdog_Sync_level>                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   48fe0:	41f9 0005 8830 	lea 58830 <_Watchdog_Ticks_chain>,%a0             	<== NOT EXECUTED
  _Watchdog_Ticks_since_boot = 0;

  _Chain_Initialize_empty( &_Watchdog_Ticks_chain );
  _Chain_Initialize_empty( &_Watchdog_Seconds_chain );
}
   48fe6:	43f9 0005 8824 	lea 58824 <_Watchdog_Seconds_chain>,%a1           	<== NOT EXECUTED
   48fec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   48fee:	23c8 0005 8838 	movel %a0,58838 <_Watchdog_Ticks_chain+0x8>       	<== NOT EXECUTED
   48ff4:	23c9 0005 882c 	movel %a1,5882c <_Watchdog_Seconds_chain+0x8>     	<== NOT EXECUTED

void _Watchdog_Handler_initialization( void )
{
  _Watchdog_Sync_count = 0;
  _Watchdog_Sync_level = 0;
  _Watchdog_Ticks_since_boot = 0;
   48ffa:	42b9 0005 889c 	clrl 5889c <_Watchdog_Ticks_since_boot>           	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   49000:	20bc 0005 8834 	movel #362548,%a0@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   49006:	42b9 0005 8834 	clrl 58834 <_Watchdog_Ticks_chain+0x4>            	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4900c:	22bc 0005 8828 	movel #362536,%a1@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   49012:	42b9 0005 8828 	clrl 58828 <_Watchdog_Seconds_chain+0x4>          	<== NOT EXECUTED

  _Chain_Initialize_empty( &_Watchdog_Ticks_chain );
  _Chain_Initialize_empty( &_Watchdog_Seconds_chain );
}
   49018:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048ed4 <_Watchdog_Insert>:

void _Watchdog_Insert(
  Chain_Control         *header,
  Watchdog_Control      *the_watchdog
)
{
   48ed4:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   48ed8:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   48edc:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Watchdog_Control  *after;
  uint32_t           insert_isr_nest_level;
  Watchdog_Interval  delta_interval;


  insert_isr_nest_level   = _ISR_Nest_level;
   48ee0:	2639 0005 87f2 	movel 587f2 <_ISR_Nest_level>,%d3                 	<== NOT EXECUTED

  _ISR_Disable( level );
   48ee6:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   48eec:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   48eee:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   48ef0:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   48ef2:	46c0           	movew %d0,%sr                                     	<== 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 ) {
   48ef4:	4aaa 0008      	tstl %a2@(8)                                      	<== NOT EXECUTED
   48ef8:	6600 00cc      	bnew 48fc6 <_Watchdog_Insert+0xf2>                	<== NOT EXECUTED
    _ISR_Enable( level );
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
  _Watchdog_Sync_count++;
   48efc:	2039 0005 8898 	movel 58898 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
    _ISR_Enable( level );
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
   48f02:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
  _Watchdog_Sync_count++;
   48f04:	5280           	addql #1,%d0                                      	<== 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 );
   48f06:	2241           	moveal %d1,%a1                                    	<== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
    _ISR_Enable( level );
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
   48f08:	2542 0008      	movel %d2,%a2@(8)                                 	<== NOT EXECUTED
  _Watchdog_Sync_count++;
   48f0c:	23c0 0005 8898 	movel %d0,58898 <_Watchdog_Sync_count>            	<== NOT EXECUTED
   * cache *header!!
   *
   *  Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
   *
   */
  for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
   48f12:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
  _Watchdog_Sync_count++;

restart:
  delta_interval = the_watchdog->initial;
   48f16:	242a 000c      	movel %a2@(12),%d2                                	<== NOT EXECUTED
   * cache *header!!
   *
   *  Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
   *
   */
  for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
   48f1a:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
        ;
        after = _Watchdog_Next( after ) ) {

     if ( delta_interval == 0 || !_Watchdog_Next( after ) )
   48f1c:	6764           	beqs 48f82 <_Watchdog_Insert+0xae>                	<== NOT EXECUTED
   48f1e:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   48f20:	6760           	beqs 48f82 <_Watchdog_Insert+0xae>                	<== NOT EXECUTED
       break;

     if ( delta_interval < after->delta_interval ) {
   48f22:	2228 0010      	movel %a0@(16),%d1                                	<== NOT EXECUTED
   48f26:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   48f28:	6252           	bhis 48f7c <_Watchdog_Insert+0xa8>                	<== 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 );
   48f2a:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   48f2c:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   48f2e:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   48f30:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
   48f32:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   48f34:	b0aa 0008      	cmpl %a2@(8),%d0                                  	<== NOT EXECUTED
   48f38:	666e           	bnes 48fa8 <_Watchdog_Insert+0xd4>                	<== NOT EXECUTED
       goto exit_insert;
     }

     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
   48f3a:	2039 0005 880e 	movel 5880e <_Watchdog_Sync_level>,%d0            	<== NOT EXECUTED
   48f40:	b083           	cmpl %d3,%d0                                      	<== NOT EXECUTED
   48f42:	6230           	bhis 48f74 <_Watchdog_Insert+0xa0>                	<== NOT EXECUTED
     if ( delta_interval < after->delta_interval ) {
       after->delta_interval -= delta_interval;
       break;
     }

     delta_interval -= after->delta_interval;
   48f44:	9481           	subl %d1,%d2                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.next );
   48f46:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
   */
  for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
        ;
        after = _Watchdog_Next( after ) ) {

     if ( delta_interval == 0 || !_Watchdog_Next( after ) )
   48f48:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   48f4a:	6736           	beqs 48f82 <_Watchdog_Insert+0xae>                	<== NOT EXECUTED
   48f4c:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   48f4e:	6732           	beqs 48f82 <_Watchdog_Insert+0xae>                	<== NOT EXECUTED
       break;

     if ( delta_interval < after->delta_interval ) {
   48f50:	2228 0010      	movel %a0@(16),%d1                                	<== NOT EXECUTED
   48f54:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   48f56:	6524           	bcss 48f7c <_Watchdog_Insert+0xa8>                	<== 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 );
   48f58:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   48f5a:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   48f5c:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   48f5e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
     if ( delta_interval < after->delta_interval ) {
       after->delta_interval -= delta_interval;
       break;
     }

     delta_interval -= after->delta_interval;
   48f60:	9481           	subl %d1,%d2                                      	<== NOT EXECUTED
      *  mechanism used here WAS redesigned to address this.
      */

     _ISR_Flash( level );

     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
   48f62:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   48f64:	b2aa 0008      	cmpl %a2@(8),%d1                                  	<== NOT EXECUTED
   48f68:	663e           	bnes 48fa8 <_Watchdog_Insert+0xd4>                	<== NOT EXECUTED
       goto exit_insert;
     }

     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
   48f6a:	2039 0005 880e 	movel 5880e <_Watchdog_Sync_level>,%d0            	<== NOT EXECUTED
   48f70:	b083           	cmpl %d3,%d0                                      	<== NOT EXECUTED
   48f72:	63d2           	blss 48f46 <_Watchdog_Insert+0x72>                	<== NOT EXECUTED
       _Watchdog_Sync_level = insert_isr_nest_level;
   48f74:	23c3 0005 880e 	movel %d3,5880e <_Watchdog_Sync_level>            	<== NOT EXECUTED
   48f7a:	6096           	bras 48f12 <_Watchdog_Insert+0x3e>                	<== NOT EXECUTED

     if ( delta_interval == 0 || !_Watchdog_Next( after ) )
       break;

     if ( delta_interval < after->delta_interval ) {
       after->delta_interval -= delta_interval;
   48f7c:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED
   48f7e:	2141 0010      	movel %d1,%a0@(16)                                	<== NOT EXECUTED

  _Watchdog_Activate( the_watchdog );

  the_watchdog->delta_interval = delta_interval;

  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
   48f82:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   48f86:	2250           	moveal %a0@,%a1                                   	<== NOT EXECUTED

  the_watchdog->start_time = _Watchdog_Ticks_since_boot;
   48f88:	2039 0005 889c 	movel 5889c <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
  after_node->next      = the_node;
   48f8e:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_ACTIVE;
   48f90:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   48f92:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   48f96:	2541 0008      	movel %d1,%a2@(8)                                 	<== NOT EXECUTED
   48f9a:	2540 0014      	movel %d0,%a2@(20)                                	<== NOT EXECUTED
     }
  }

  _Watchdog_Activate( the_watchdog );

  the_watchdog->delta_interval = delta_interval;
   48f9e:	2542 0010      	movel %d2,%a2@(16)                                	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
   48fa2:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
   48fa6:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );

  the_watchdog->start_time = _Watchdog_Ticks_since_boot;

exit_insert:
  _Watchdog_Sync_level = insert_isr_nest_level;
   48fa8:	23c3 0005 880e 	movel %d3,5880e <_Watchdog_Sync_level>            	<== NOT EXECUTED
  _Watchdog_Sync_count--;
   48fae:	2039 0005 8898 	movel 58898 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
   48fb4:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   48fb6:	23c0 0005 8898 	movel %d0,58898 <_Watchdog_Sync_count>            	<== NOT EXECUTED
  _ISR_Enable( level );
   48fbc:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   48fbe:	4cd7 0c1c      	moveml %sp@,%d2-%d4/%a2-%a3                       	<== NOT EXECUTED
   48fc2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48fc4:	4e75           	rts                                               	<== NOT EXECUTED
   *  Check to see if the watchdog has just been inserted by a
   *  higher priority interrupt.  If so, abandon this insert.
   */

  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
    _ISR_Enable( level );
   48fc6:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED

exit_insert:
  _Watchdog_Sync_level = insert_isr_nest_level;
  _Watchdog_Sync_count--;
  _ISR_Enable( level );
}
   48fc8:	4cd7 0c1c      	moveml %sp@,%d2-%d4/%a2-%a3                       	<== NOT EXECUTED
   48fcc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48fce:	4e75           	rts

0004901c <_Watchdog_Remove>:
 */

Watchdog_States _Watchdog_Remove(
  Watchdog_Control *the_watchdog
)
{
   4901c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49020:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level         level;
  Watchdog_States   previous_state;
  Watchdog_Control *next_watchdog;

  _ISR_Disable( level );
   49022:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Watchdog_States _Watchdog_Remove(
  Watchdog_Control *the_watchdog
)
{
   49028:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4902a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level         level;
  Watchdog_States   previous_state;
  Watchdog_Control *next_watchdog;

  _ISR_Disable( level );
   4902e:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   49030:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   49032:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  previous_state = the_watchdog->state;
   49034:	222a 0008      	movel %a2@(8),%d1                                 	<== NOT EXECUTED
  switch ( previous_state ) {
   49038:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4903a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4903c:	6766           	beqs 490a4 <_Watchdog_Remove+0x88>                	<== NOT EXECUTED
   4903e:	6316           	blss 49056 <_Watchdog_Remove+0x3a>                	<== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;

      _Chain_Extract_unprotected( &the_watchdog->Node );
      break;
  }
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
   49040:	2039 0005 889c 	movel 5889c <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
   49046:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   4904a:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return( previous_state );
}
   4904c:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4904e:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   49050:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49052:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49054:	4e75           	rts                                               	<== NOT EXECUTED
  Watchdog_States   previous_state;
  Watchdog_Control *next_watchdog;

  _ISR_Disable( level );
  previous_state = the_watchdog->state;
  switch ( previous_state ) {
   49056:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   4905a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4905c:	65e2           	bcss 49040 <_Watchdog_Remove+0x24>                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.next );
   4905e:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
      break;

    case WATCHDOG_ACTIVE:
    case WATCHDOG_REMOVE_IT:

      the_watchdog->state = WATCHDOG_INACTIVE;
   49060:	42aa 0008      	clrl %a2@(8)                                      	<== NOT EXECUTED
      next_watchdog = _Watchdog_Next( the_watchdog );

      if ( _Watchdog_Next(next_watchdog) )
   49064:	4a91           	tstl %a1@                                         	<== NOT EXECUTED
   49066:	6708           	beqs 49070 <_Watchdog_Remove+0x54>                	<== NOT EXECUTED
        next_watchdog->delta_interval += the_watchdog->delta_interval;
   49068:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4906c:	d1a9 0010      	addl %d0,%a1@(16)                                 	<== NOT EXECUTED

      if ( _Watchdog_Sync_count )
   49070:	2039 0005 8898 	movel 58898 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
   49076:	670c           	beqs 49084 <_Watchdog_Remove+0x68>                	<== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;
   49078:	2039 0005 87f2 	movel 587f2 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   4907e:	23c0 0005 880e 	movel %d0,5880e <_Watchdog_Sync_level>            	<== NOT EXECUTED
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
   49084:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED

      _Chain_Extract_unprotected( &the_watchdog->Node );
      break;
  }
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
   49088:	2039 0005 889c 	movel 5889c <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   4908e:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   49090:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
   49094:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   49098:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return( previous_state );
}
   4909a:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4909c:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4909e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   490a0:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   490a2:	4e75           	rts                                               	<== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;

      _Chain_Extract_unprotected( &the_watchdog->Node );
      break;
  }
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
   490a4:	2039 0005 889c 	movel 5889c <_Watchdog_Ticks_since_boot>,%d0      	<== 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;
   490aa:	42aa 0008      	clrl %a2@(8)                                      	<== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;

      _Chain_Extract_unprotected( &the_watchdog->Node );
      break;
  }
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
   490ae:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   490b2:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return( previous_state );
}
   490b4:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   490b6:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   490b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   490ba:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   490bc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000490c0 <_Watchdog_Tickle>:
 */

void _Watchdog_Tickle(
  Chain_Control *header
)
{
   490c0:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   490c4:	48d7 3c0c      	moveml %d2-%d3/%a2-%a5,%sp@                       	<== 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 );
   490c8:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _Watchdog_Tickle(
  Chain_Control *header
)
{
   490ce:	2a6e 0008      	moveal %fp@(8),%a5                                	<== 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 );
   490d2:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   490d4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   490d6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   490d8:	264d           	moveal %a5,%a3                                    	<== NOT EXECUTED
   490da:	205b           	moveal %a3@+,%a0                                  	<== NOT EXECUTED

  if ( _Chain_Is_empty( header ) )
   490dc:	b7c8           	cmpal %a0,%a3                                     	<== NOT EXECUTED
   490de:	6740           	beqs 49120 <_Watchdog_Tickle+0x60>                	<== 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) {
   490e0:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
  Chain_Control *header
)
{

  return ( (Watchdog_Control *) header->first );
   490e4:	2448           	moveal %a0,%a2                                    	<== NOT EXECUTED
   490e6:	49f9 0004 901c 	lea 4901c <_Watchdog_Remove>,%a4                  	<== NOT EXECUTED
   490ec:	6708           	beqs 490f6 <_Watchdog_Tickle+0x36>                	<== NOT EXECUTED
    the_watchdog->delta_interval--;
   490ee:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   490f0:	2140 0010      	movel %d0,%a0@(16)                                	<== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )
   490f4:	662a           	bnes 49120 <_Watchdog_Tickle+0x60>                	<== NOT EXECUTED

       case WATCHDOG_REMOVE_IT:
         break;
     }

	 _ISR_Disable( level );
   490f6:	263c 0000 0700 	movel #1792,%d3                                   	<== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )
      goto leave;
  }

  do {
     watchdog_state = _Watchdog_Remove( the_watchdog );
   490fc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   490fe:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

     _ISR_Enable( level );
   49100:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

     switch( watchdog_state ) {
   49102:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   49104:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   49106:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49108:	6722           	beqs 4912c <_Watchdog_Tickle+0x6c>                	<== NOT EXECUTED

       case WATCHDOG_REMOVE_IT:
         break;
     }

	 _ISR_Disable( level );
   4910a:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   4910c:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   4910e:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   49110:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   49112:	2015           	movel %a5@,%d0                                    	<== NOT EXECUTED
   49114:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

     the_watchdog = _Watchdog_First( header );
   } while ( !_Chain_Is_empty( header ) &&
             (the_watchdog->delta_interval == 0) );
   49116:	b08b           	cmpl %a3,%d0                                      	<== NOT EXECUTED
   49118:	6706           	beqs 49120 <_Watchdog_Tickle+0x60>                	<== NOT EXECUTED
   4911a:	4aaa 0010      	tstl %a2@(16)                                     	<== NOT EXECUTED
   4911e:	67dc           	beqs 490fc <_Watchdog_Tickle+0x3c>                	<== NOT EXECUTED

leave:
   _ISR_Enable(level);
   49120:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   49122:	4cee 3c0c ffe8 	moveml %fp@(-24),%d2-%d3/%a2-%a5                  	<== NOT EXECUTED
   49128:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4912a:	4e75           	rts                                               	<== NOT EXECUTED

     _ISR_Enable( level );

     switch( watchdog_state ) {
       case WATCHDOG_ACTIVE:
         (*the_watchdog->routine)(
   4912c:	2f2a 0024      	movel %a2@(36),%sp@-                              	<== NOT EXECUTED
   49130:	2f2a 0020      	movel %a2@(32),%sp@-                              	<== NOT EXECUTED
   49134:	206a 001c      	moveal %a2@(28),%a0                               	<== NOT EXECUTED
   49138:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4913a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4913c:	60cc           	bras 4910a <_Watchdog_Tickle+0x4a>                	<== NOT EXECUTED
	...

00049158 <_Workspace_Allocate>:
 *  _Workspace_Allocate
 */
void *_Workspace_Allocate(
  size_t   size
)
{
   49158:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Heap_Allocate( &_Workspace_Area, size );
   4915c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49160:	4879 0005 8776 	pea 58776 <_Workspace_Area>                       	<== NOT EXECUTED
   49166:	4eb9 0004 b404 	jsr 4b404 <_Heap_Allocate>                        	<== NOT EXECUTED
}
   4916c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4916e:	4e75           	rts

00049170 <_Workspace_Allocate_or_fatal_error>:
 *  _Workspace_Allocate_or_fatal_error
 */
void *_Workspace_Allocate_or_fatal_error(
  size_t      size
)
{
   49170:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
void *_Workspace_Allocate(
  size_t   size
)
{
   return _Heap_Allocate( &_Workspace_Area, size );
   49174:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49178:	4879 0005 8776 	pea 58776 <_Workspace_Area>                       	<== NOT EXECUTED
   4917e:	4eb9 0004 b404 	jsr 4b404 <_Heap_Allocate>                        	<== NOT EXECUTED
{
  void        *memory;

  memory = _Workspace_Allocate( size );

  if ( memory == NULL )
   49184:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   49186:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49188:	6704           	beqs 4918e <_Workspace_Allocate_or_fatal_error+0x1e>	<== NOT EXECUTED
      TRUE,
      INTERNAL_ERROR_WORKSPACE_ALLOCATION
    );

  return memory;
}
   4918a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4918c:	4e75           	rts                                               	<== NOT EXECUTED
  void        *memory;

  memory = _Workspace_Allocate( size );

  if ( memory == NULL )
    _Internal_error_Occurred(
   4918e:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49192:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   49196:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   49198:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED

00049140 <_Workspace_Free>:
 *  _Workspace_Free
 */
bool _Workspace_Free(
  void *block
)
{
   49140:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Heap_Free( &_Workspace_Area, block );
   49144:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49148:	4879 0005 8776 	pea 58776 <_Workspace_Area>                       	<== NOT EXECUTED
   4914e:	4eb9 0004 b4c8 	jsr 4b4c8 <_Heap_Free>                            	<== NOT EXECUTED
}
   49154:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49156:	4e75           	rts

0004919e <_Workspace_Handler_initialization>:
 */
void _Workspace_Handler_initialization(
  void       *starting_address,
  size_t      size
)
{
   4919e:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   491a2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   491a4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  uint32_t    memory_available;

  if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
   491a8:	6706           	beqs 491b0 <_Workspace_Handler_initialization+0x12>	<== NOT EXECUTED
   491aa:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   491ac:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   491ae:	6710           	beqs 491c0 <_Workspace_Handler_initialization+0x22>	<== NOT EXECUTED
    _Internal_error_Occurred(
   491b0:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   491b4:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   491b8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   491ba:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
    );

  if ( _Configuration_Table->do_zero_of_workspace )
   491c0:	2079 0005 87ee 	moveal 587ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   491c6:	4a28 0028      	tstb %a0@(40)                                     	<== NOT EXECUTED
   491ca:	6628           	bnes 491f4 <_Workspace_Handler_initialization+0x56>	<== NOT EXECUTED
   memset( starting_address, 0, size );

  memory_available = _Heap_Initialize(
   491cc:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   491d0:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   491d4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   491d6:	4879 0005 8776 	pea 58776 <_Workspace_Area>                       	<== NOT EXECUTED
   491dc:	4eb9 0004 6c48 	jsr 46c48 <_Heap_Initialize>                      	<== NOT EXECUTED
    starting_address,
    size,
    CPU_HEAP_ALIGNMENT
  );

  if ( memory_available == 0 )
   491e2:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   491e8:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   491ea:	671e           	beqs 4920a <_Workspace_Handler_initialization+0x6c>	<== NOT EXECUTED
    _Internal_error_Occurred(
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
    );
}
   491ec:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   491f0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   491f2:	4e75           	rts                                               	<== NOT EXECUTED
      TRUE,
      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
    );

  if ( _Configuration_Table->do_zero_of_workspace )
   memset( starting_address, 0, size );
   491f4:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   491f8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   491fa:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   491fc:	4eb9 0004 ce28 	jsr 4ce28 <memset>                                	<== NOT EXECUTED
   49202:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49208:	60c2           	bras 491cc <_Workspace_Handler_initialization+0x2e>	<== NOT EXECUTED
    size,
    CPU_HEAP_ALIGNMENT
  );

  if ( memory_available == 0 )
    _Internal_error_Occurred(
   4920a:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED
   4920e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   49212:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   49214:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
	...

00045fb0 <rtems_barrier_create>:
  rtems_name           name,
  rtems_attribute      attribute_set,
  uint32_t             maximum_waiters,
  rtems_id            *id
)
{
   45fb0:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   45fb4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Barrier_Control         *the_barrier;
  CORE_barrier_Attributes  the_attributes;

  if ( !rtems_is_name_valid( name ) )
   45fb6:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   45fba:	6700 0096      	beqw 46052 <rtems_barrier_create+0xa2>            	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   45fbe:	4aae 0014      	tstl %fp@(20)                                     	<== NOT EXECUTED
   45fc2:	6700 00e4      	beqw 460a8 <rtems_barrier_create+0xf8>            	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  /* Initialize core barrier attributes */
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
   45fc6:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   45fca:	0800 0004      	btst #4,%d0                                       	<== NOT EXECUTED
   45fce:	6700 008c      	beqw 4605c <rtems_barrier_create+0xac>            	<== NOT EXECUTED
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
    if ( maximum_waiters == 0 )
   45fd2:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   45fd6:	6700 00c6      	beqw 4609e <rtems_barrier_create+0xee>            	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   45fda:	2039 0005 ab7c 	movel 5ab7c <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;
  } else
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
  the_attributes.maximum_count = maximum_waiters;
   45fe0:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   45fe4:	5280           	addql #1,%d0                                      	<== 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;
   45fe6:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
    if ( maximum_waiters == 0 )
      return RTEMS_INVALID_NUMBER;
  } else
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
  the_attributes.maximum_count = maximum_waiters;
   45fea:	2d48 fffc      	movel %a0,%fp@(-4)                                	<== NOT EXECUTED
   45fee:	23c0 0005 ab7c 	movel %d0,5ab7c <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  This function allocates a barrier control block from
 *  the inactive chain of free barrier control blocks.
 */
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
  return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
   45ff4:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   45ffa:	4eb9 0004 7f80 	jsr 47f80 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* prevents deletion */

  the_barrier = _Barrier_Allocate();

  if ( !the_barrier ) {
   46000:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46002:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   46004:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46006:	6700 0086      	beqw 4608e <rtems_barrier_create+0xde>            	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_barrier->attribute_set = attribute_set;
   4600a:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   4600e:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED

  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
   46012:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   46016:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   4601a:	4eb9 0004 7678 	jsr 47678 <_CORE_barrier_Initialize>              	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   46020:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
    &_Barrier_Information,
    &the_barrier->Object,
    (Objects_Name) name
  );

  *id = the_barrier->Object.id;
   46024:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   46028:	2541 000c      	movel %d1,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4602c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4602e:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   46032:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   46036:	2079 0005 aa8e 	moveal 5aa8e <_Barrier_Information+0x1a>,%a0      	<== NOT EXECUTED
   4603c:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED

  _Thread_Enable_dispatch();
   46040:	4eb9 0004 8d30 	jsr 48d30 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46046:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
    (Objects_Name) name
  );

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
   4604a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4604c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    (Objects_Name) name
  );

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
   4604e:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46050:	4e75           	rts                                               	<== NOT EXECUTED
   46052:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   46056:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Barrier_Control         *the_barrier;
  CORE_barrier_Attributes  the_attributes;

  if ( !rtems_is_name_valid( name ) )
   46058:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4605a:	4e75           	rts                                               	<== NOT EXECUTED
   4605c:	2039 0005 ab7c 	movel 5ab7c <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
    if ( maximum_waiters == 0 )
      return RTEMS_INVALID_NUMBER;
  } else
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
  the_attributes.maximum_count = maximum_waiters;
   46062:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
    if ( maximum_waiters == 0 )
      return RTEMS_INVALID_NUMBER;
  } else
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
   46066:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46068:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4606a:	2d41 fff8      	movel %d1,%fp@(-8)                                	<== NOT EXECUTED
  the_attributes.maximum_count = maximum_waiters;
   4606e:	2d48 fffc      	movel %a0,%fp@(-4)                                	<== NOT EXECUTED
   46072:	23c0 0005 ab7c 	movel %d0,5ab7c <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   46078:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   4607e:	4eb9 0004 7f80 	jsr 47f80 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* prevents deletion */

  the_barrier = _Barrier_Allocate();

  if ( !the_barrier ) {
   46084:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46086:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   46088:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4608a:	6600 ff7e      	bnew 4600a <rtems_barrier_create+0x5a>            	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4608e:	4eb9 0004 8d30 	jsr 48d30 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46094:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   46098:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();             /* prevents deletion */

  the_barrier = _Barrier_Allocate();

  if ( !the_barrier ) {
    _Thread_Enable_dispatch();
   4609a:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4609c:	4e75           	rts                                               	<== NOT EXECUTED
   4609e:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   460a2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  /* Initialize core barrier attributes */
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
    if ( maximum_waiters == 0 )
   460a4:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   460a6:	4e75           	rts                                               	<== NOT EXECUTED
   460a8:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   460ac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  CORE_barrier_Attributes  the_attributes;

  if ( !rtems_is_name_valid( name ) )
    return RTEMS_INVALID_NAME;

  if ( !id )
   460ae:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

  *id = the_barrier->Object.id;

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   460b0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000460b4 <rtems_barrier_delete>:
 */

rtems_status_code rtems_barrier_delete(
  rtems_id   id
)
{
   460b4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   460b8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Barrier_Control *)
   460ba:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   460be:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   460c2:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   460c8:	4eb9 0004 84ac 	jsr 484ac <_Objects_Get>                          	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   460ce:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   460d4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   460d6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   460da:	6642           	bnes 4611e <rtems_barrier_delete+0x6a>            	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _CORE_barrier_Flush(
   460dc:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   460e0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   460e2:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   460e6:	4eb9 0004 9514 	jsr 49514 <_Thread_queue_Flush>                   	<== NOT EXECUTED
        &the_barrier->Barrier,
        NULL,
        CORE_BARRIER_WAS_DELETED
      );

      _Objects_Close( &_Barrier_Information, &the_barrier->Object );
   460ec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   460ee:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   460f4:	4eb9 0004 801c 	jsr 4801c <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Barrier_Free (
  Barrier_Control *the_barrier
)
{
  _Objects_Free( &_Barrier_Information, &the_barrier->Object );
   460fa:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   460fc:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   46102:	4eb9 0004 8340 	jsr 48340 <_Objects_Free>                         	<== NOT EXECUTED

      _Barrier_Free( the_barrier );

      _Thread_Enable_dispatch();
   46108:	4eb9 0004 8d30 	jsr 48d30 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4610e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED

      _Objects_Close( &_Barrier_Information, &the_barrier->Object );

      _Barrier_Free( the_barrier );

      _Thread_Enable_dispatch();
   46112:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46118:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

      _Objects_Close( &_Barrier_Information, &the_barrier->Object );

      _Barrier_Free( the_barrier );

      _Thread_Enable_dispatch();
   4611a:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4611c:	4e75           	rts                                               	<== NOT EXECUTED
   4611e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46122:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   46124:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46126:	4e75           	rts

00046128 <rtems_barrier_ident>:

rtems_status_code rtems_barrier_ident(
  rtems_name  name,
  rtems_id   *id
)
{
   46128:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   4612c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   46130:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   46136:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4613a:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   46140:	4eb9 0004 8644 	jsr 48644 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   46146:	41f9 0005 800c 	lea 5800c <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   4614c:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   46150:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46152:	4e75           	rts

00046154 <rtems_barrier_release>:

rtems_status_code rtems_barrier_release(
  rtems_id          id,
  uint32_t         *released
)
{
   46154:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   46158:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4615a:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  if ( !released )
   4615e:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   46160:	6754           	beqs 461b6 <rtems_barrier_release+0x62>           	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Barrier_Control *)
   46162:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46166:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4616a:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   46170:	4eb9 0004 84ac 	jsr 484ac <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   46176:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4617c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4617e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46182:	6628           	bnes 461ac <rtems_barrier_release+0x58>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
   46184:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46186:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4618a:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4618e:	4eb9 0004 76b4 	jsr 476b4 <_CORE_barrier_Release>                 	<== NOT EXECUTED
   46194:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   46196:	4eb9 0004 8d30 	jsr 48d30 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4619c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
      _Thread_Enable_dispatch();
   461a0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   461a6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
      _Thread_Enable_dispatch();
   461a8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   461aa:	4e75           	rts                                               	<== NOT EXECUTED
   461ac:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   461b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !released )
    return RTEMS_INVALID_ADDRESS;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   461b2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   461b4:	4e75           	rts                                               	<== NOT EXECUTED
   461b6:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   461ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  if ( !released )
   461bc:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   461be:	4e75           	rts

000461c0 <rtems_barrier_wait>:

rtems_status_code rtems_barrier_wait(
  rtems_id        id,
  rtems_interval  timeout
)
{
   461c0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   461c4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   461c6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   461ca:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   461ce:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   461d0:	4879 0005 aa74 	pea 5aa74 <_Barrier_Information>                  	<== NOT EXECUTED
   461d6:	4eb9 0004 84ac 	jsr 484ac <_Objects_Get>                          	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   461dc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   461e2:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   461e4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   461e8:	663a           	bnes 46224 <rtems_barrier_wait+0x64>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _CORE_barrier_Wait(
   461ea:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   461ec:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   461f0:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   461f4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   461f6:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   461fa:	4eb9 0004 76f0 	jsr 476f0 <_CORE_barrier_Wait>                    	<== NOT EXECUTED
        id,
        TRUE,
        timeout,
        NULL
      );
      _Thread_Enable_dispatch();
   46200:	4eb9 0004 8d30 	jsr 48d30 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return _Barrier_Translate_core_barrier_return_code(
   46206:	2079 0005 ac3a 	moveal 5ac3a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4620c:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   46210:	4eb9 0004 bdc0 	jsr 4bdc0 <_Barrier_Translate_core_barrier_return_code>	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46216:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
        TRUE,
        timeout,
        NULL
      );
      _Thread_Enable_dispatch();
      return _Barrier_Translate_core_barrier_return_code(
   4621a:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46220:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46222:	4e75           	rts                                               	<== NOT EXECUTED
   46224:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46228:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   4622a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4622c:	4e75           	rts                                               	<== NOT EXECUTED
	...

000470cc <rtems_build_id>:
  uint32_t api,
  uint32_t class,
  uint32_t node,
  uint32_t index
)
{
   470cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   470d0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   470d2:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   470d6:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   470da:	761b           	moveq #27,%d3                                     	<== NOT EXECUTED
   470dc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   470de:	e7a8           	lsll %d3,%d0                                      	<== NOT EXECUTED
   470e0:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   470e4:	163c 0018      	moveb #24,%d3                                     	<== NOT EXECUTED
   470e8:	e7a9           	lsll %d3,%d1                                      	<== NOT EXECUTED
   470ea:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   470ec:	80ae 0014      	orl %fp@(20),%d0                                  	<== NOT EXECUTED
   470f0:	4842           	swap %d2                                          	<== NOT EXECUTED
   470f2:	4242           	clrw %d2                                          	<== NOT EXECUTED
  return _Objects_Build_id( api, class, node, index );
}
   470f4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   470f6:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   470f8:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   470fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   470fc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047100 <rtems_build_name>:
  char C1,
  char C2,
  char C3,
  char C4
)
{
   47100:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47104:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47106:	142e 000b      	moveb %fp@(11),%d2                                	<== NOT EXECUTED
   4710a:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   4710c:	102e 000f      	moveb %fp@(15),%d0                                	<== NOT EXECUTED
   47110:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   47112:	e3aa           	lsll %d1,%d2                                      	<== NOT EXECUTED
   47114:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   47116:	122e 0013      	moveb %fp@(19),%d1                                	<== NOT EXECUTED
   4711a:	4840           	swap %d0                                          	<== NOT EXECUTED
   4711c:	4240           	clrw %d0                                          	<== NOT EXECUTED
   4711e:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47120:	49c1           	extbl %d1                                         	<== NOT EXECUTED
   47122:	142e 0017      	moveb %fp@(23),%d2                                	<== NOT EXECUTED
   47126:	e189           	lsll #8,%d1                                       	<== NOT EXECUTED
   47128:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   4712a:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
  return _Objects_Build_name( C1, C2, C3, C4 );
}
   4712c:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4712e:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47130:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47132:	4e75           	rts

00045274 <rtems_clock_get>:

rtems_status_code rtems_clock_get(
  rtems_clock_get_options  option,
  void                    *time_buffer
)
{
   45274:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45278:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4527a:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4527e:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  if ( !time_buffer )
   45282:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45284:	6778           	beqs 452fe <rtems_clock_get+0x8a>                 	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  switch ( option ) {
   45286:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   45288:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4528a:	640a           	bccs 45296 <rtems_clock_get+0x22>                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   4528c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45290:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  switch ( option ) {
   45292:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   45294:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  switch ( option ) {
   45296:	303b 0a08      	movew %pc@(452a0 <rtems_clock_get+0x2c>,%d0:l:2),%d0	<== NOT EXECUTED
   4529a:	48c0           	extl %d0                                          	<== NOT EXECUTED
   4529c:	4efb 0802      	jmp %pc@(452a0 <rtems_clock_get+0x2c>,%d0:l)      	<== NOT EXECUTED
   452a0:	004e           	0116                                              	<== NOT EXECUTED
   452a2:	003e           	076                                               	<== NOT EXECUTED
   452a4:	002c           	054                                               	<== NOT EXECUTED
   452a6:	001a           	032                                               	<== NOT EXECUTED
   452a8:	000a           	012                                               	<== 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 );
   452aa:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452ae:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   452b2:	4e5e           	unlk %fp                                          	<== 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 );
   452b4:	4ef9 0004 5424 	jmp 45424 <rtems_clock_get_tod_timeval>           	<== 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();
   452ba:	4eb9 0004 5334 	jsr 45334 <rtems_clock_get_ticks_per_second>      	<== NOT EXECUTED
   452c0:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452c2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   452c6:	4e5e           	unlk %fp                                          	<== 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();
   452c8:	4280           	clrl %d0                                          	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452ca:	4e75           	rts                                               	<== NOT EXECUTED
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);

    case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
      rtems_interval *interval = (rtems_interval *)time_buffer;

      *interval = rtems_clock_get_ticks_since_boot();
   452cc:	4eb9 0004 534c 	jsr 4534c <rtems_clock_get_ticks_since_boot>      	<== NOT EXECUTED
   452d2:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452d4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   452d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);

    case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
      rtems_interval *interval = (rtems_interval *)time_buffer;

      *interval = rtems_clock_get_ticks_since_boot();
   452da:	4280           	clrl %d0                                          	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452dc:	4e75           	rts                                               	<== 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);
   452de:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452e2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   452e6:	4e5e           	unlk %fp                                          	<== 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);
   452e8:	4ef9 0004 5308 	jmp 45308 <rtems_clock_get_seconds_since_epoch>   	<== 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 );
   452ee:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452f2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   452f6:	4e5e           	unlk %fp                                          	<== 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 );
   452f8:	4ef9 0004 535c 	jmp 4535c <rtems_clock_get_tod>                   	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   452fe:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45302:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
rtems_status_code rtems_clock_get(
  rtems_clock_get_options  option,
  void                    *time_buffer
)
{
  if ( !time_buffer )
   45304:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   45306:	4e75           	rts

00045308 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_seconds_since_epoch(
  rtems_interval *the_interval
)
{
   45308:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4530c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( !the_interval )
   45310:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   45312:	671a           	beqs 4532e <rtems_clock_get_seconds_since_epoch+0x26>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   45314:	4a39 0005 8768 	tstb 58768 <_TOD_Is_set>                          	<== NOT EXECUTED
   4531a:	670c           	beqs 45328 <rtems_clock_get_seconds_since_epoch+0x20>	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  *the_interval = _TOD_Seconds_since_epoch;
   4531c:	20b9 0005 87e6 	movel 587e6 <_TOD_Now>,%a0@                       	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45322:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
    return RTEMS_NOT_DEFINED;

  *the_interval = _TOD_Seconds_since_epoch;
   45324:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45326:	4e75           	rts                                               	<== NOT EXECUTED
   45328:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( !the_interval )
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   4532a:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  *the_interval = _TOD_Seconds_since_epoch;
  return RTEMS_SUCCESSFUL;
}
   4532c:	4e75           	rts                                               	<== NOT EXECUTED
   4532e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

rtems_status_code rtems_clock_get_seconds_since_epoch(
  rtems_interval *the_interval
)
{
  if ( !the_interval )
   45330:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  if ( !_TOD_Is_set )
    return RTEMS_NOT_DEFINED;

  *the_interval = _TOD_Seconds_since_epoch;
  return RTEMS_SUCCESSFUL;
}
   45332:	4e75           	rts

00045334 <rtems_clock_get_ticks_per_second>:
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>

rtems_interval rtems_clock_get_ticks_per_second(void)
{
   45334:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick;
}
   45338:	41f9 0005 88e2 	lea 588e2 <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   4533e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45340:	203c 000f 4240 	movel #1000000,%d0                                	<== NOT EXECUTED
   45346:	4c50 0000      	remul %a0@,%d0,%d0                                	<== NOT EXECUTED
   4534a:	4e75           	rts

0004534c <rtems_clock_get_ticks_since_boot>:
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>

rtems_interval rtems_clock_get_ticks_since_boot(void)
{
   4534c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Watchdog_Ticks_since_boot;
   45350:	2039 0005 889c 	movel 5889c <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
}
   45356:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45358:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004535c <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_tod(
  rtems_time_of_day  *time_buffer
)
{
   4535c:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
   45360:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45362:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   45366:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  rtems_time_of_day *tmbuf = time_buffer;
  struct tm time;
  struct timeval now;

  if ( !time_buffer )
   45368:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4536a:	6700 00aa      	beqw 45416 <rtems_clock_get_tod+0xba>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   4536e:	4a39 0005 8768 	tstb 58768 <_TOD_Is_set>                          	<== NOT EXECUTED
   45374:	660e           	bnes 45384 <rtems_clock_get_tod+0x28>             	<== NOT EXECUTED
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;

  return RTEMS_SUCCESSFUL;
}
   45376:	242e ffc4      	movel %fp@(-60),%d2                               	<== NOT EXECUTED
   4537a:	246e ffc8      	moveal %fp@(-56),%a2                              	<== NOT EXECUTED
   4537e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  struct timeval now;

  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   45380:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;

  return RTEMS_SUCCESSFUL;
}
   45382:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  ISR_Level level;
  struct timespec now;

  _ISR_Disable(level);
   45384:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4538a:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   4538c:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4538e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _TOD_Get( &now );
   45390:	486e fff0      	pea %fp@(-16)                                     	<== NOT EXECUTED
   45394:	4eb9 0004 6b34 	jsr 46b34 <_TOD_Get>                              	<== NOT EXECUTED
  _ISR_Enable(level);
   4539a:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  /* Obtain the current time */
  _TOD_Get_timeval( &now );

  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );
   4539c:	486e ffcc      	pea %fp@(-52)                                     	<== NOT EXECUTED

  time->tv_sec  = now.tv_sec;
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   453a0:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED
   453a4:	243c 0000 03e8 	movel #1000,%d2                                   	<== NOT EXECUTED
   453aa:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED

  _ISR_Disable(level);
    _TOD_Get( &now );
  _ISR_Enable(level);

  time->tv_sec  = now.tv_sec;
   453ae:	2d6e fff0 fff8 	movel %fp@(-16),%fp@(-8)                          	<== NOT EXECUTED
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   453b4:	2d41 fffc      	movel %d1,%fp@(-4)                                	<== NOT EXECUTED
   453b8:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   453bc:	4eb9 0004 cd9c 	jsr 4cd9c <gmtime_r>                              	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
  tmbuf->day    = time.tm_mday;
  tmbuf->hour   = time.tm_hour;
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;
   453c2:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   453c6:	41f9 0005 88e2 	lea 588e2 <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   453cc:	4c50 1001      	remul %a0@,%d1,%d1                                	<== NOT EXECUTED
   453d0:	2541 0018      	movel %d1,%a2@(24)                                	<== NOT EXECUTED

  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );

  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
   453d4:	222e ffe0      	movel %fp@(-32),%d1                               	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
   453d8:	242e ffdc      	movel %fp@(-36),%d2                               	<== NOT EXECUTED
  tmbuf->day    = time.tm_mday;
   453dc:	256e ffd8 0008 	movel %fp@(-40),%a2@(8)                           	<== NOT EXECUTED
  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );

  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
  tmbuf->month  = time.tm_mon + 1;
   453e2:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
  tmbuf->day    = time.tm_mday;
  tmbuf->hour   = time.tm_hour;
   453e4:	256e ffd4 000c 	movel %fp@(-44),%a2@(12)                          	<== NOT EXECUTED

  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );

  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
   453ea:	0681 0000 076c 	addil #1900,%d1                                   	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
  tmbuf->day    = time.tm_mday;
  tmbuf->hour   = time.tm_hour;
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;
   453f0:	4280           	clrl %d0                                          	<== NOT EXECUTED
  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );

  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
  tmbuf->month  = time.tm_mon + 1;
   453f2:	2542 0004      	movel %d2,%a2@(4)                                 	<== NOT EXECUTED
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;

  return RTEMS_SUCCESSFUL;
}
   453f6:	242e ffc4      	movel %fp@(-60),%d2                               	<== NOT EXECUTED

  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );

  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
   453fa:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
  tmbuf->day    = time.tm_mday;
  tmbuf->hour   = time.tm_hour;
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;
   453fc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  /* Now adjust it to the RTEMS format */
  tmbuf->year   = time.tm_year + 1900;
  tmbuf->month  = time.tm_mon + 1;
  tmbuf->day    = time.tm_mday;
  tmbuf->hour   = time.tm_hour;
  tmbuf->minute = time.tm_min;
   45402:	256e ffd0 0010 	movel %fp@(-48),%a2@(16)                          	<== NOT EXECUTED
  tmbuf->second = time.tm_sec;
   45408:	256e ffcc 0014 	movel %fp@(-52),%a2@(20)                          	<== NOT EXECUTED
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;

  return RTEMS_SUCCESSFUL;
}
   4540e:	246e ffc8      	moveal %fp@(-56),%a2                              	<== NOT EXECUTED
   45412:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45414:	4e75           	rts                                               	<== NOT EXECUTED
   45416:	242e ffc4      	movel %fp@(-60),%d2                               	<== NOT EXECUTED
   4541a:	246e ffc8      	moveal %fp@(-56),%a2                              	<== NOT EXECUTED
   4541e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  rtems_time_of_day *tmbuf = time_buffer;
  struct tm time;
  struct timeval now;

  if ( !time_buffer )
   45420:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  tmbuf->minute = time.tm_min;
  tmbuf->second = time.tm_sec;
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;

  return RTEMS_SUCCESSFUL;
}
   45422:	4e75           	rts

00045424 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_tod_timeval(
  struct timeval  *time
)
{
   45424:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   45428:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4542a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4542e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  if ( !time )
   45430:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45432:	6754           	beqs 45488 <rtems_clock_get_tod_timeval+0x64>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   45434:	4a39 0005 8768 	tstb 58768 <_TOD_Is_set>                          	<== NOT EXECUTED
   4543a:	660e           	bnes 4544a <rtems_clock_get_tod_timeval+0x26>     	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  _TOD_Get_timeval( time );

  return RTEMS_SUCCESSFUL;
}
   4543c:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   45440:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   45444:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( !time )
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   45446:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  _TOD_Get_timeval( time );

  return RTEMS_SUCCESSFUL;
}
   45448:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  ISR_Level level;
  struct timespec now;

  _ISR_Disable(level);
   4544a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   45450:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   45452:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45454:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _TOD_Get( &now );
   45456:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   4545a:	4eb9 0004 6b34 	jsr 46b34 <_TOD_Get>                              	<== NOT EXECUTED
  _ISR_Enable(level);
   45460:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  time->tv_sec  = now.tv_sec;
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   45462:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   45466:	243c 0000 03e8 	movel #1000,%d2                                   	<== NOT EXECUTED
   4546c:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED
   45470:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
   45474:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED

  _ISR_Disable(level);
    _TOD_Get( &now );
  _ISR_Enable(level);

  time->tv_sec  = now.tv_sec;
   45478:	24ae fff8      	movel %fp@(-8),%a2@                               	<== NOT EXECUTED
   4547c:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   45480:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45482:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45484:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45486:	4e75           	rts                                               	<== NOT EXECUTED
   45488:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   4548c:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   45490:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

rtems_status_code rtems_clock_get_tod_timeval(
  struct timeval  *time
)
{
  if ( !time )
   45492:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  _TOD_Get_timeval( time );

  return RTEMS_SUCCESSFUL;
}
   45494:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045674 <rtems_clock_get_uptime>:
 *    error code       - if unsuccessful
 */
rtems_status_code rtems_clock_get_uptime(
  struct timespec *uptime
)
{
   45674:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45678:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  if ( !uptime )
   4567c:	6710           	beqs 4568e <rtems_clock_get_uptime+0x1a>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _TOD_Get_uptime( uptime );
   4567e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45680:	4eb9 0004 6f94 	jsr 46f94 <_TOD_Get_uptime>                       	<== NOT EXECUTED
   45686:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45688:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( !uptime )
    return RTEMS_INVALID_ADDRESS;

  _TOD_Get_uptime( uptime );
   4568a:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4568c:	4e75           	rts                                               	<== NOT EXECUTED
   4568e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
 */
rtems_status_code rtems_clock_get_uptime(
  struct timespec *uptime
)
{
  if ( !uptime )
   45690:	103c 0009      	moveb #9,%d0                                      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _TOD_Get_uptime( uptime );
  return RTEMS_SUCCESSFUL;
}
   45694:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046334 <rtems_clock_set>:
 */

rtems_status_code rtems_clock_set(
  rtems_time_of_day *time_buffer
)
{
   46334:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   46338:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   4633c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  struct timespec  newtime;

  if ( !time_buffer )
   46340:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   46342:	6772           	beqs 463b6 <rtems_clock_set+0x82>                 	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( _TOD_Validate( time_buffer ) ) {
   46344:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46346:	4eb9 0004 6538 	jsr 46538 <_TOD_Validate>                         	<== NOT EXECUTED
   4634c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4634e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46350:	660c           	bnes 4635e <rtems_clock_set+0x2a>                 	<== NOT EXECUTED
      _TOD_Set( &newtime );
    _Thread_Enable_dispatch();
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   46352:	4cee 040c ffec 	moveml %fp@(-20),%d2-%d3/%a2                      	<== NOT EXECUTED
   46358:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  struct timespec  newtime;

  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  if ( _TOD_Validate( time_buffer ) ) {
   4635a:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
      _TOD_Set( &newtime );
    _Thread_Enable_dispatch();
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   4635c:	4e75           	rts                                               	<== NOT EXECUTED

  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  if ( _TOD_Validate( time_buffer ) ) {
    newtime.tv_sec = _TOD_To_seconds( time_buffer );
   4635e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46360:	4eb9 0004 6404 	jsr 46404 <_TOD_To_seconds>                       	<== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *
   46366:	242a 0018      	movel %a2@(24),%d2                                	<== NOT EXECUTED
   4636a:	41f9 0006 2f0a 	lea 62f0a <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   46370:	4c10 2800      	mulsl %a0@,%d2                                    	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   46374:	2079 0006 2d7c 	moveal 62d7c <_Thread_Dispatch_disable_level>,%a0 	<== NOT EXECUTED
   4637a:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   4637c:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4637e:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   46380:	ef89           	lsll #7,%d1                                       	<== NOT EXECUTED
   46382:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
   46384:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   46386:	5288           	addql #1,%a0                                      	<== NOT EXECUTED
   46388:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   4638a:	2d41 fffc      	movel %d1,%fp@(-4)                                	<== NOT EXECUTED
   4638e:	23c8 0006 2d7c 	movel %a0,62d7c <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

  if ( !time_buffer )
    return RTEMS_INVALID_ADDRESS;

  if ( _TOD_Validate( time_buffer ) ) {
    newtime.tv_sec = _TOD_To_seconds( time_buffer );
   46394:	2d40 fff8      	movel %d0,%fp@(-8)                                	<== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *
                 (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);

    _Thread_Disable_dispatch();
      _TOD_Set( &newtime );
   46398:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   4639c:	4eb9 0004 7f24 	jsr 47f24 <_TOD_Set>                              	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   463a2:	4eb9 0004 9194 	jsr 49194 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   463a8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   463aa:	4cee 040c ffec 	moveml %fp@(-20),%d2-%d3/%a2                      	<== NOT EXECUTED
   463b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *
                 (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);

    _Thread_Disable_dispatch();
      _TOD_Set( &newtime );
    _Thread_Enable_dispatch();
   463b2:	4280           	clrl %d0                                          	<== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   463b4:	4e75           	rts                                               	<== NOT EXECUTED
   463b6:	4cee 040c ffec 	moveml %fp@(-20),%d2-%d3/%a2                      	<== NOT EXECUTED
   463bc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  rtems_time_of_day *time_buffer
)
{
  struct timespec  newtime;

  if ( !time_buffer )
   463be:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
      _TOD_Set( &newtime );
    _Thread_Enable_dispatch();
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   463c0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045498 <rtems_clock_set_nanoseconds_extension>:
 *    error code        - if unsuccessful
 */
rtems_status_code rtems_clock_set_nanoseconds_extension(
  rtems_nanoseconds_extension_routine routine
)
{
   45498:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4549c:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
  if ( !routine )
   454a0:	670c           	beqs 454ae <rtems_clock_set_nanoseconds_extension+0x16>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _Watchdog_Nanoseconds_since_tick_handler = routine;
  return RTEMS_SUCCESSFUL;
}
   454a2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  if ( !routine )
    return RTEMS_INVALID_ADDRESS;

  _Watchdog_Nanoseconds_since_tick_handler = routine;
   454a4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   454a6:	23c1 0005 88ea 	movel %d1,588ea <_Watchdog_Nanoseconds_since_tick_handler>	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   454ac:	4e75           	rts                                               	<== NOT EXECUTED
   454ae:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
 */
rtems_status_code rtems_clock_set_nanoseconds_extension(
  rtems_nanoseconds_extension_routine routine
)
{
  if ( !routine )
   454b0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _Watchdog_Nanoseconds_since_tick_handler = routine;
  return RTEMS_SUCCESSFUL;
}
   454b2:	4e75           	rts

000454b4 <rtems_clock_tick>:
 *
 *  NOTE: This routine only works for leap-years through 2099.
 */

rtems_status_code rtems_clock_tick( void )
{
   454b4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _TOD_Tickle_ticks();
   454b8:	4eb9 0004 6bcc 	jsr 46bcc <_TOD_Tickle_ticks>                     	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{

  _Watchdog_Tickle( &_Watchdog_Ticks_chain );
   454be:	4879 0005 8830 	pea 58830 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   454c4:	4eb9 0004 90c0 	jsr 490c0 <_Watchdog_Tickle>                      	<== NOT EXECUTED

  _Watchdog_Tickle_ticks();

  _Thread_Tickle_timeslice();
   454ca:	4eb9 0004 8a98 	jsr 48a98 <_Thread_Tickle_timeslice>              	<== NOT EXECUTED

  if ( _Thread_Is_context_switch_necessary() &&
   454d0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
  return ( _Context_Switch_necessary );
   454d2:	1039 0005 8822 	moveb 58822 <_Context_Switch_necessary>,%d0       	<== NOT EXECUTED
   454d8:	6708           	beqs 454e2 <rtems_clock_tick+0x2e>                	<== NOT EXECUTED
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
  return ( _Thread_Dispatch_disable_level == 0 );
   454da:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   454e0:	6706           	beqs 454e8 <rtems_clock_tick+0x34>                	<== NOT EXECUTED
       _Thread_Is_dispatching_enabled() )
    _Thread_Dispatch();

  return RTEMS_SUCCESSFUL;
}
   454e2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   454e4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   454e6:	4e75           	rts                                               	<== NOT EXECUTED

  _Thread_Tickle_timeslice();

  if ( _Thread_Is_context_switch_necessary() &&
       _Thread_Is_dispatching_enabled() )
    _Thread_Dispatch();
   454e8:	4eb9 0004 7b60 	jsr 47b60 <_Thread_Dispatch>                      	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   454ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   454f0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   454f2:	4e75           	rts

0004b14c <rtems_debug_disable>:
 */

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
   4b14c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Debug_Level &= ~to_be_disabled;
   4b150:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
}
   4b154:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
  _Debug_Level &= ~to_be_disabled;
   4b156:	4680           	notl %d0                                          	<== NOT EXECUTED
   4b158:	c1b9 0005 8816 	andl %d0,58816 <_Debug_Level>                     	<== NOT EXECUTED
}
   4b15e:	4e75           	rts

0004b13a <rtems_debug_enable>:
 */

void rtems_debug_enable (
  rtems_debug_control  to_be_enabled
)
{
   4b13a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Debug_Level |= to_be_enabled;
   4b13e:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
}
   4b142:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

void rtems_debug_enable (
  rtems_debug_control  to_be_enabled
)
{
  _Debug_Level |= to_be_enabled;
   4b144:	81b9 0005 8816 	orl %d0,58816 <_Debug_Level>                      	<== NOT EXECUTED
}
   4b14a:	4e75           	rts

000454f4 <rtems_event_receive>:
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   454f4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   454f8:	226e 0014      	moveal %fp@(20),%a1                               	<== NOT EXECUTED
  RTEMS_API_Control       *api;

  if ( !event_out )
   454fc:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   454fe:	6754           	beqs 45554 <rtems_event_receive+0x60>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
   45500:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45506:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED

  if ( _Event_sets_Is_empty( event_in ) ) {
   4550a:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   4550e:	6608           	bnes 45518 <rtems_event_receive+0x24>             	<== NOT EXECUTED
    *event_out = api->pending_events;
   45510:	2290           	movel %a0@,%a1@                                   	<== NOT EXECUTED

  _Thread_Disable_dispatch();
  _Event_Seize( event_in, option_set, ticks, event_out );
  _Thread_Enable_dispatch();
  return( _Thread_Executing->Wait.return_code );
}
   45512:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];

  if ( _Event_sets_Is_empty( event_in ) ) {
    *event_out = api->pending_events;
   45514:	4280           	clrl %d0                                          	<== NOT EXECUTED

  _Thread_Disable_dispatch();
  _Event_Seize( event_in, option_set, ticks, event_out );
  _Thread_Enable_dispatch();
  return( _Thread_Executing->Wait.return_code );
}
   45516:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   45518:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4551e:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45520:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    *event_out = api->pending_events;
    return RTEMS_SUCCESSFUL;
  }

  _Thread_Disable_dispatch();
  _Event_Seize( event_in, option_set, ticks, event_out );
   45526:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   45528:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4552c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   45530:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45534:	4eb9 0004 555c 	jsr 4555c <_Event_Seize>                          	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   4553a:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return( _Thread_Executing->Wait.return_code );
   45540:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45546:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4554c:	2028 0034      	movel %a0@(52),%d0                                	<== NOT EXECUTED
}
   45550:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45552:	4e75           	rts                                               	<== NOT EXECUTED
   45554:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  rtems_event_set *event_out
)
{
  RTEMS_API_Control       *api;

  if ( !event_out )
   45556:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

  _Thread_Disable_dispatch();
  _Event_Seize( event_in, option_set, ticks, event_out );
  _Thread_Enable_dispatch();
  return( _Thread_Executing->Wait.return_code );
}
   45558:	4e75           	rts                                               	<== NOT EXECUTED
	...

000456a0 <rtems_event_send>:

rtems_status_code rtems_event_send(
  Objects_Id        id,
  rtems_event_set   event_in
)
{
   456a0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  the_thread = _Thread_Get( id, &location );
   456a4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   456a8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   456ac:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   456b2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  the_thread = _Thread_Get( id, &location );
   456b4:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
  switch ( location ) {
   456b6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   456ba:	662e           	bnes 456ea <rtems_event_send+0x4a>                	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
   456bc:	2069 010c      	moveal %a1@(268),%a0                              	<== NOT EXECUTED
  rtems_event_set *the_event_set
)
{
  ISR_Level level;

  _ISR_Disable( level );
   456c0:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   456c6:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   456c8:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   456ca:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    *the_event_set |= the_new_events;
   456cc:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   456d0:	8390           	orl %d1,%a0@                                      	<== NOT EXECUTED
  _ISR_Enable( level );
   456d2:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
      _Event_sets_Post( event_in, &api->pending_events );
      _Event_Surrender( the_thread );
   456d4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   456d6:	4eb9 0004 56f0 	jsr 456f0 <_Event_Surrender>                      	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   456dc:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   456e2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   456e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      _Event_sets_Post( event_in, &api->pending_events );
      _Event_Surrender( the_thread );
      _Thread_Enable_dispatch();
   456e6:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   456e8:	4e75           	rts                                               	<== NOT EXECUTED
   456ea:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   456ec:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   456ee:	4e75           	rts

0004baa0 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
  rtems_name              name,
  rtems_extensions_table *extension_table,
  Objects_Id             *id
)
{
   4baa0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4baa4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Extension_Control *the_extension;

  if ( !id )
   4baa6:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   4baaa:	6700 0084      	beqw 4bb30 <rtems_extension_create+0x90>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   4baae:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   4bab2:	660a           	bnes 4babe <rtems_extension_create+0x1e>          	<== NOT EXECUTED
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4bab4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4bab8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Extension_Control *the_extension;

  if ( !id )
    return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   4baba:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4babc:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4babe:	2039 0006 6bdc 	movel 66bdc <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4bac4:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4bac6:	23c0 0006 6bdc 	movel %d0,66bdc <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  the inactive chain of free extension control blocks.
 */

RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
  return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
   4bacc:	4879 0006 6d92 	pea 66d92 <_Extension_Information>                	<== NOT EXECUTED
   4bad2:	4eb9 0004 c79c 	jsr 4c79c <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_extension = _Extension_Allocate();

  if ( !the_extension ) {
   4bad8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4bada:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4badc:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4bade:	6740           	beqs 4bb20 <rtems_extension_create+0x80>          	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  _User_extensions_Add_set( &the_extension->Extension, extension_table );
   4bae0:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4bae4:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4bae8:	4eb9 0004 e570 	jsr 4e570 <_User_extensions_Add_set>              	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4baee:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
    &_Extension_Information,
    &the_extension->Object,
    (Objects_Name) name
  );

  *id = the_extension->Object.id;
   4baf2:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   4baf6:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4bafa:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4bafc:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   4bb00:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   4bb04:	2079 0006 6dac 	moveal 66dac <_Extension_Information+0x1a>,%a0    	<== NOT EXECUTED
   4bb0a:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   4bb0e:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4bb14:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
    &the_extension->Object,
    (Objects_Name) name
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
   4bb18:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4bb1a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    &the_extension->Object,
    (Objects_Name) name
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
   4bb1c:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4bb1e:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_extension = _Extension_Allocate();

  if ( !the_extension ) {
    _Thread_Enable_dispatch();
   4bb20:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4bb26:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4bb2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_extension = _Extension_Allocate();

  if ( !the_extension ) {
    _Thread_Enable_dispatch();
   4bb2c:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4bb2e:	4e75           	rts                                               	<== NOT EXECUTED
   4bb30:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4bb34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id             *id
)
{
  Extension_Control *the_extension;

  if ( !id )
   4bb36:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  );

  *id = the_extension->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4bb38:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004bb3c <rtems_extension_delete>:
 */

rtems_status_code rtems_extension_delete(
  Objects_Id id
)
{
   4bb3c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4bb40:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Extension_Control *)
   4bb42:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4bb46:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4bb4a:	4879 0006 6d92 	pea 66d92 <_Extension_Information>                	<== NOT EXECUTED
   4bb50:	4eb9 0004 ccc8 	jsr 4ccc8 <_Objects_Get>                          	<== NOT EXECUTED
  Extension_Control   *the_extension;
  Objects_Locations    location;

  the_extension = _Extension_Get( id, &location );
  switch ( location ) {
   4bb56:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4bb5c:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4bb5e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4bb62:	663c           	bnes 4bba0 <rtems_extension_delete+0x64>          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _User_extensions_Remove_set( &the_extension->Extension );
   4bb64:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4bb68:	4eb9 0004 e698 	jsr 4e698 <_User_extensions_Remove_set>           	<== NOT EXECUTED
      _Objects_Close( &_Extension_Information, &the_extension->Object );
   4bb6e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4bb70:	4879 0006 6d92 	pea 66d92 <_Extension_Information>                	<== NOT EXECUTED
   4bb76:	4eb9 0004 c838 	jsr 4c838 <_Objects_Close>                        	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Extension_Free (
  Extension_Control *the_extension
)
{
  _Objects_Free( &_Extension_Information, &the_extension->Object );
   4bb7c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4bb7e:	4879 0006 6d92 	pea 66d92 <_Extension_Information>                	<== NOT EXECUTED
   4bb84:	4eb9 0004 cb5c 	jsr 4cb5c <_Objects_Free>                         	<== NOT EXECUTED
      _Extension_Free( the_extension );
      _Thread_Enable_dispatch();
   4bb8a:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4bb90:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
  switch ( location ) {
    case OBJECTS_LOCAL:
      _User_extensions_Remove_set( &the_extension->Extension );
      _Objects_Close( &_Extension_Information, &the_extension->Object );
      _Extension_Free( the_extension );
      _Thread_Enable_dispatch();
   4bb94:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4bb9a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {
    case OBJECTS_LOCAL:
      _User_extensions_Remove_set( &the_extension->Extension );
      _Objects_Close( &_Extension_Information, &the_extension->Object );
      _Extension_Free( the_extension );
      _Thread_Enable_dispatch();
   4bb9c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4bb9e:	4e75           	rts                                               	<== NOT EXECUTED
   4bba0:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4bba4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Extension_Control   *the_extension;
  Objects_Locations    location;

  the_extension = _Extension_Get( id, &location );
  switch ( location ) {
   4bba6:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4bba8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000481dc <rtems_extension_ident>:

rtems_status_code rtems_extension_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   481dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   481e0:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   481e4:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   481ea:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   481ee:	4879 0005 c70a 	pea 5c70a <_Extension_Information>                	<== NOT EXECUTED
   481f4:	4eb9 0004 9480 	jsr 49480 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   481fa:	41f9 0005 97c4 	lea 597c4 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   48200:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   48204:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48206:	4e75           	rts

00046388 <rtems_fatal_error_occurred>:
 */

void rtems_fatal_error_occurred(
  uint32_t   the_error
)
{
   46388:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error );
   4638c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46390:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46392:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46396:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED

00047de8 <rtems_get_version_string>:
#endif

#include <rtems/system.h>

const char *rtems_get_version_string(void)
{
   47de8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _RTEMS_version;
}
   47dec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47dee:	203c 0005 a334 	movel #369460,%d0                                 	<== NOT EXECUTED
   47df4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046206 <rtems_initialize_before_drivers>:
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}

void rtems_initialize_before_drivers(void)
{
   46206:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   *  Run the API and BSPs predriver hook.
   */

  _API_extensions_Run_predriver();

}
   4620a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  /*
   *  Run the API and BSPs predriver hook.
   */

  _API_extensions_Run_predriver();
   4620c:	4ef9 0004 6524 	jmp 46524 <_API_extensions_Run_predriver>         	<== NOT EXECUTED

00046212 <rtems_initialize_data_structures>:
Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ];

void rtems_initialize_data_structures(
  rtems_configuration_table *configuration_table
)
{
   46212:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46216:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46218:	246e 0008      	moveal %fp@(8),%a2                                	<== 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 );
   4621c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46222:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   46224:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   46226:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  /*
   *  Make sure the parameters were not NULL.
   */
  if ( configuration_table == NULL )
   46228:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4622a:	6700 00f0      	beqw 4631c <rtems_initialize_data_structures+0x10a>	<== NOT EXECUTED
  _Configuration_Table    = configuration_table;

  /*
   * Initialize any target architecture specific support as early as possible
   */
  _CPU_Initialize( _Thread_Dispatch );
   4622e:	4879 0004 7b60 	pea 47b60 <_Thread_Dispatch>                      	<== NOT EXECUTED
    );

  /*
   *  Provide pointers just for later convenience.
   */
  _Configuration_Table    = configuration_table;
   46234:	23ca 0005 87ee 	movel %a2,587ee <_Configuration_Table>            	<== NOT EXECUTED

  /*
   * Initialize any target architecture specific support as early as possible
   */
  _CPU_Initialize( _Thread_Dispatch );
   4623a:	4eb9 0004 92e0 	jsr 492e0 <_CPU_Initialize>                       	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization (
  bool  is_multiprocessing
)
{
  _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION;
   46240:	42b9 0005 88e6 	clrl 588e6 <_System_state_Current>                	<== NOT EXECUTED
  /*
   *  Do this as early as possible to insure no debugging output
   *  is even attempted to be printed.
   */

  _Debug_Manager_initialization();
   46246:	4eb9 0004 b12c 	jsr 4b12c <_Debug_Manager_initialization>         	<== NOT EXECUTED

  _API_extensions_Initialization();
   4624c:	4eb9 0004 6504 	jsr 46504 <_API_extensions_Initialization>        	<== NOT EXECUTED

  /*
   *  Before this is called, we are not allowed to allocate memory
   *  from the Workspace because it is not initialized.
   */
  _Workspace_Handler_initialization(
   46252:	2f2a 0004      	movel %a2@(4),%sp@-                               	<== NOT EXECUTED
 *  This routine initializes the thread dispatching subsystem.
 */

RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void )
{
  _Thread_Dispatch_disable_level = 1;
   46256:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46258:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   4625e:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   46260:	4eb9 0004 919e 	jsr 4919e <_Workspace_Handler_initialization>     	<== NOT EXECUTED
     (void *)configuration_table->work_space_start,
     configuration_table->work_space_size
  );

  _User_extensions_Handler_initialization(
   46266:	2f2a 003a      	movel %a2@(58),%sp@-                              	<== NOT EXECUTED
   4626a:	2f2a 0036      	movel %a2@(54),%sp@-                              	<== NOT EXECUTED
   4626e:	4eb9 0004 8c40 	jsr 48c40 <_User_extensions_Handler_initialization>	<== NOT EXECUTED
    configuration_table->number_of_initial_extensions,
    configuration_table->User_extension_table
  );

  _ISR_Handler_initialization();
   46274:	4eb9 0004 6e9c 	jsr 46e9c <_ISR_Handler_initialization>           	<== NOT EXECUTED

  _Objects_Handler_initialization(
   4627a:	4eb9 0004 7654 	jsr 47654 <_Objects_Handler_initialization>       	<== NOT EXECUTED
  _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects;

  /*
   * Initialize the internal allocator Mutex
   */
  _API_Mutex_Initialization( 1 );
   46280:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
    _Configuration_MP_table->maximum_nodes,
    _Configuration_MP_table->maximum_global_objects
#endif
  );

  _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects;
   46284:	203c 0005 876a 	movel #362346,%d0                                 	<== NOT EXECUTED
   4628a:	23c0 0005 8710 	movel %d0,58710 <_Objects_Information_table+0x4>  	<== NOT EXECUTED

  /*
   * Initialize the internal allocator Mutex
   */
  _API_Mutex_Initialization( 1 );
   46290:	4eb9 0004 6674 	jsr 46674 <_API_Mutex_Initialization>             	<== NOT EXECUTED
  _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex );
   46296:	4879 0005 880a 	pea 5880a <_RTEMS_Allocator_Mutex>                	<== NOT EXECUTED
   4629c:	4eb9 0004 65d8 	jsr 465d8 <_API_Mutex_Allocate>                   	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void )
{
  size_t index;

  _Priority_Major_bit_map = 0;
   462a2:	4240           	clrw %d0                                          	<== NOT EXECUTED
   462a4:	33c0 0005 8808 	movew %d0,58808 <_Priority_Major_bit_map>         	<== NOT EXECUTED
   462aa:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   462b0:	41f9 0005 8878 	lea 58878 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
  for ( index=0 ; index <16 ; index++ )
     _Priority_Bit_map[ index ] = 0;
   462b6:	4258           	clrw %a0@+                                        	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void )
{
  size_t index;

  _Priority_Major_bit_map = 0;
  for ( index=0 ; index <16 ; index++ )
   462b8:	b1fc 0005 8898 	cmpal #362648,%a0                                 	<== NOT EXECUTED
   462be:	66f6           	bnes 462b6 <rtems_initialize_data_structures+0xa4>	<== NOT EXECUTED

  _Priority_Handler_initialization();

  _Watchdog_Handler_initialization();
   462c0:	4eb9 0004 8fd0 	jsr 48fd0 <_Watchdog_Handler_initialization>      	<== NOT EXECUTED

  _TOD_Handler_initialization( configuration_table->microseconds_per_tick );
   462c6:	2f2a 000c      	movel %a2@(12),%sp@-                              	<== NOT EXECUTED
   462ca:	4eb9 0004 6b94 	jsr 46b94 <_TOD_Handler_initialization>           	<== NOT EXECUTED

  _Thread_Handler_initialization(
   462d0:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   462d4:	2f2a 0010      	movel %a2@(16),%sp@-                              	<== NOT EXECUTED
   462d8:	4eb9 0004 7fd4 	jsr 47fd4 <_Thread_Handler_initialization>        	<== NOT EXECUTED
  );
#endif

/* MANAGERS */

  _RTEMS_API_Initialize( configuration_table );
   462de:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   462e0:	4eb9 0004 6470 	jsr 46470 <_RTEMS_API_Initialize>                 	<== NOT EXECUTED

  _Extension_Manager_initialization( configuration_table->maximum_extensions );
   462e6:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   462ea:	4eb9 0004 6358 	jsr 46358 <_Extension_Manager_initialization>     	<== NOT EXECUTED

  _IO_Manager_initialization(
   462f0:	2f2a 002a      	movel %a2@(42),%sp@-                              	<== NOT EXECUTED
   462f4:	2f2a 002e      	movel %a2@(46),%sp@-                              	<== NOT EXECUTED
   462f8:	2f2a 0032      	movel %a2@(50),%sp@-                              	<== NOT EXECUTED
   462fc:	4eb9 0004 63d8 	jsr 463d8 <_IO_Manager_initialization>            	<== NOT EXECUTED
  _Thread_Create_idle();

  /*
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}
   46302:	246e fffc      	moveal %fp@(-4),%a2                               	<== 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();
   46306:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED

  /*
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}
   4630c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   4630e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46310:	23c0 0005 88e6 	movel %d0,588e6 <_System_state_Current>           	<== 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();
   46316:	4ef9 0004 7a70 	jmp 47a70 <_Thread_Create_idle>                   	<== NOT EXECUTED

  /*
   *  Make sure the parameters were not NULL.
   */
  if ( configuration_table == NULL )
    _Internal_error_Occurred(
   4631c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4631e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46322:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46324:	4eb9 0004 6e40 	jsr 46e40 <_Internal_error_Occurred>              	<== NOT EXECUTED
	...

000461f4 <rtems_initialize_device_drivers>:
  _API_extensions_Run_predriver();

}

void rtems_initialize_device_drivers(void)
{
   461f4:	4e56 0000      	linkw %fp,#0                                      	<== 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();
   461f8:	4eb9 0004 639c 	jsr 4639c <_IO_Initialize_all_drivers>            	<== NOT EXECUTED
   *
   *  The API extensions are supposed to create user initialization tasks.
   */

  _API_extensions_Run_postdriver();
}
   461fe:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   *  Run the APIs and BSPs postdriver hooks.
   *
   *  The API extensions are supposed to create user initialization tasks.
   */

  _API_extensions_Run_postdriver();
   46200:	4ef9 0004 6554 	jmp 46554 <_API_extensions_Run_postdriver>        	<== NOT EXECUTED

000461e0 <rtems_initialize_start_multitasking>:

  _API_extensions_Run_postdriver();
}

void rtems_initialize_start_multitasking(void)
{
   461e0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   ******                 APPLICATION RUNS HERE                 ******
   ******            RETURNS WHEN SYSTEM IS SHUT DOWN           ******
   *******************************************************************
   *******************************************************************
   *******************************************************************/
}
   461e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   461e6:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   461e8:	23c0 0005 88e6 	movel %d0,588e6 <_System_state_Current>           	<== NOT EXECUTED
void rtems_initialize_start_multitasking(void)
{

  _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING );

  _Thread_Start_multitasking();
   461ee:	4ef9 0004 88cc 	jmp 488cc <_Thread_Start_multitasking>            	<== NOT EXECUTED

000458dc <rtems_interrupt_catch>:
rtems_status_code rtems_interrupt_catch(
  rtems_isr_entry      new_isr_handler,
  rtems_vector_number  vector,
  rtems_isr_entry     *old_isr_handler
)
{
   458dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   458e0:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
  if ( !_ISR_Is_vector_number_valid( vector ) )
   458e4:	0c80 0000 00ff 	cmpil #255,%d0                                    	<== NOT EXECUTED
   458ea:	622e           	bhis 4591a <rtems_interrupt_catch+0x3e>           	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
   458ec:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   458f0:	6722           	beqs 45914 <rtems_interrupt_catch+0x38>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
   458f2:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   458f6:	671c           	beqs 45914 <rtems_interrupt_catch+0x38>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _ISR_Install_vector(
   458f8:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   458fc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45900:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45902:	4eb9 0004 931a 	jsr 4931a <_CPU_ISR_install_vector>               	<== NOT EXECUTED
   45908:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );

  return RTEMS_SUCCESSFUL;
}
   4590e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
    return RTEMS_INVALID_ADDRESS;

  _ISR_Install_vector(
   45910:	4280           	clrl %d0                                          	<== NOT EXECUTED
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );

  return RTEMS_SUCCESSFUL;
}
   45912:	4e75           	rts                                               	<== NOT EXECUTED
   45914:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _ISR_Install_vector(
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );

  return RTEMS_SUCCESSFUL;
   45916:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   45918:	4e75           	rts                                               	<== NOT EXECUTED
   4591a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  rtems_isr_entry      new_isr_handler,
  rtems_vector_number  vector,
  rtems_isr_entry     *old_isr_handler
)
{
  if ( !_ISR_Is_vector_number_valid( vector ) )
   4591c:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED

  _ISR_Install_vector(
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );

  return RTEMS_SUCCESSFUL;
}
   4591e:	4e75           	rts

0004658c <rtems_interrupt_disable>:
 */

#undef rtems_interrupt_disable

rtems_interrupt_level rtems_interrupt_disable( void )
{
   4658c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  rtems_interrupt_level previous_level;

  _ISR_Disable( previous_level );
   46590:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   46596:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   46598:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4659a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  return previous_level;
}
   4659c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4659e:	4e75           	rts

000465a0 <rtems_interrupt_enable>:
#undef rtems_interrupt_enable

void rtems_interrupt_enable(
  rtems_interrupt_level previous_level
)
{
   465a0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _ISR_Enable( previous_level );
   465a4:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   465a8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   465aa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465ac:	4e75           	rts

000465ae <rtems_interrupt_flash>:
#undef rtems_interrupt_flash

void rtems_interrupt_flash(
  rtems_interrupt_level previous_level
)
{
   465ae:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _ISR_Flash( previous_level );
   465b2:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   465b8:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   465bc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   465be:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   465c0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   465c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465c4:	4e75           	rts

000465c6 <rtems_interrupt_is_in_progress>:

#undef rtems_interrupt_is_in_progress

bool rtems_interrupt_is_in_progress( void )
{
  return _ISR_Is_in_progress();
   465c6:	2039 0005 aae2 	movel 5aae2 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
 */

#undef rtems_interrupt_is_in_progress

bool rtems_interrupt_is_in_progress( void )
{
   465cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _ISR_Is_in_progress();
   465d0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   465d2:	56c0           	sne %d0                                           	<== NOT EXECUTED
}
   465d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465d6:	4480           	negl %d0                                          	<== NOT EXECUTED
   465d8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c214 <rtems_io_close>:
rtems_status_code rtems_io_close(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4c214:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c218:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4c21a:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4c21e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4c220:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4c224:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c228:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4c22e:	642c           	bccs 4c25c <rtems_io_close+0x48>                  	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].close_entry;
   4c230:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4c232:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4c234:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4c23a:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4c23c:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4c23e:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4c240:	2030 1808      	movel %a0@(00000008,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4c244:	6718           	beqs 4c25e <rtems_io_close+0x4a>                  	<== NOT EXECUTED
   4c246:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4c24a:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4c24c:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4c250:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4c254:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c256:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c258:	4e5e           	unlk %fp                                          	<== 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;
   4c25a:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c25c:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].close_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4c25e:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c260:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c262:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c264:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c268 <rtems_io_control>:
rtems_status_code rtems_io_control(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4c268:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c26c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4c26e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4c272:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4c274:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4c278:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c27c:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4c282:	642c           	bccs 4c2b0 <rtems_io_control+0x48>                	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].control_entry;
   4c284:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4c286:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4c288:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4c28e:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4c290:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4c292:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4c294:	2030 1814      	movel %a0@(00000014,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4c298:	6718           	beqs 4c2b2 <rtems_io_control+0x4a>                	<== NOT EXECUTED
   4c29a:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4c29e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4c2a0:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4c2a4:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4c2a8:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c2aa:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c2ac:	4e5e           	unlk %fp                                          	<== 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;
   4c2ae:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c2b0:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].control_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4c2b2:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c2b4:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c2b6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c2b8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b178 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4b178:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b17c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4b17e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4b182:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4b184:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4b188:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4b18c:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4b192:	642c           	bccs 4b1c0 <rtems_io_initialize+0x48>             	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].initialization_entry;
   4b194:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4b19a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4b19c:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4b19e:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4b1a0:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   4b1a2:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4b1a4:	2030 1800      	movel %a0@(00000000,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4b1a8:	6718           	beqs 4b1c2 <rtems_io_initialize+0x4a>             	<== NOT EXECUTED
   4b1aa:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4b1ae:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4b1b0:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4b1b4:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4b1b8:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4b1ba:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4b1bc:	4e5e           	unlk %fp                                          	<== 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;
   4b1be:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4b1c0:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].initialization_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4b1c2:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4b1c4:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4b1c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b1c8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c2bc <rtems_io_open>:
rtems_status_code rtems_io_open(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4c2bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c2c0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4c2c2:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4c2c6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4c2c8:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4c2cc:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c2d0:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4c2d6:	642c           	bccs 4c304 <rtems_io_open+0x48>                   	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].open_entry;
   4c2d8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4c2da:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4c2dc:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4c2e2:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4c2e4:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4c2e6:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4c2e8:	2030 1804      	movel %a0@(00000004,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4c2ec:	6718           	beqs 4c306 <rtems_io_open+0x4a>                   	<== NOT EXECUTED
   4c2ee:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4c2f2:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4c2f4:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4c2f8:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4c2fc:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c2fe:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c300:	4e5e           	unlk %fp                                          	<== 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;
   4c302:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c304:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].open_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4c306:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c308:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c30a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c30c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c310 <rtems_io_read>:
rtems_status_code rtems_io_read(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4c310:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c314:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4c316:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4c31a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4c31c:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4c320:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c324:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4c32a:	642c           	bccs 4c358 <rtems_io_read+0x48>                   	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].read_entry;
   4c32c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4c32e:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4c330:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4c336:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4c338:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4c33a:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4c33c:	2030 180c      	movel %a0@(0000000c,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4c340:	6718           	beqs 4c35a <rtems_io_read+0x4a>                   	<== NOT EXECUTED
   4c342:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4c346:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4c348:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4c34c:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4c350:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c352:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c354:	4e5e           	unlk %fp                                          	<== 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;
   4c356:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c358:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].read_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4c35a:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c35c:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c35e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c360:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472f8 <rtems_io_register_driver>:
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
)
{
   472f8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   472fc:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   47300:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   47304:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   47308:	266e 0010      	moveal %fp@(16),%a3                               	<== NOT EXECUTED

  /*
   *  Validate the pointer data and contents passed in
   */
  if ( !driver_table )
   4730c:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4730e:	6700 00b0      	beqw 473c0 <rtems_io_register_driver+0xc8>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !registered_major )
   47312:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   47314:	6700 00aa      	beqw 473c0 <rtems_io_register_driver+0xc8>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !driver_table->initialization_entry && !driver_table->open_entry )
   47318:	4a91           	tstl %a1@                                         	<== NOT EXECUTED
   4731a:	6700 009c      	beqw 473b8 <rtems_io_register_driver+0xc0>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  *registered_major = 0;
   4731e:	4293           	clrl %a3@                                         	<== NOT EXECUTED

  /*
   *  The requested major number is higher than what is configured.
   */
  if ( major >= _IO_Number_of_drivers )
   47320:	2239 0005 ac5a 	movel 5ac5a <_IO_Number_of_drivers>,%d1           	<== NOT EXECUTED
   47326:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   47328:	6464           	bccs 4738e <rtems_io_register_driver+0x96>        	<== NOT EXECUTED
  /*
   * Test for initialise/open being present to indicate the driver slot is
   * in use.
   */

  if ( major == 0 ) {
   4732a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4732c:	666a           	bnes 47398 <rtems_io_register_driver+0xa0>        	<== NOT EXECUTED
    bool found = false;
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
   4732e:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   47330:	5382           	subql #1,%d2                                      	<== NOT EXECUTED
   47332:	6722           	beqs 47356 <rtems_io_register_driver+0x5e>        	<== NOT EXECUTED
   47334:	2079 0005 ac5e 	moveal 5ac5e <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4733a:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   4733c:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   4733e:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   47340:	91c1           	subal %d1,%a0                                     	<== NOT EXECUTED
   47342:	41f0 08e8      	lea %a0@(ffffffe8,%d0:l),%a0                      	<== NOT EXECUTED
   47346:	2448           	moveal %a0,%a2                                    	<== NOT EXECUTED
      if ( !_IO_Driver_address_table[major].initialization_entry &&
   47348:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   4734a:	6714           	beqs 47360 <rtems_io_register_driver+0x68>        	<== NOT EXECUTED
   * in use.
   */

  if ( major == 0 ) {
    bool found = false;
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
   4734c:	5382           	subql #1,%d2                                      	<== NOT EXECUTED
   4734e:	d1fc ffff ffe8 	addal #-24,%a0                                    	<== NOT EXECUTED
   47354:	66f0           	bnes 47346 <rtems_io_register_driver+0x4e>        	<== NOT EXECUTED

  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
}
   47356:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   4735a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   4735c:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
}
   4735e:	4e75           	rts                                               	<== NOT EXECUTED
   */

  if ( major == 0 ) {
    bool found = false;
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
      if ( !_IO_Driver_address_table[major].initialization_entry &&
   47360:	4aa8 0004      	tstl %a0@(4)                                      	<== NOT EXECUTED
   47364:	66e6           	bnes 4734c <rtems_io_register_driver+0x54>        	<== NOT EXECUTED
  if ( _IO_Driver_address_table[major].initialization_entry ||
       _IO_Driver_address_table[major].open_entry )
    return RTEMS_RESOURCE_IN_USE;


  _IO_Driver_address_table[major] = *driver_table;
   47366:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   47368:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   4736a:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   4736c:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   4736e:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   47370:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   47372:	2091           	movel %a1@,%a0@                                   	<== NOT EXECUTED
  *registered_major               = major;
   47374:	2682           	movel %d2,%a3@                                    	<== NOT EXECUTED

  return rtems_io_initialize( major, 0, NULL );
   47376:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
   4737a:	42ae 0010      	clrl %fp@(16)                                     	<== NOT EXECUTED
   4737e:	42ae 000c      	clrl %fp@(12)                                     	<== NOT EXECUTED
}
   47382:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   47386:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   47388:	4ef9 0004 7128 	jmp 47128 <rtems_io_initialize>                   	<== NOT EXECUTED
}
   4738e:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   47392:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  *registered_major = 0;

  /*
   *  The requested major number is higher than what is configured.
   */
  if ( major >= _IO_Number_of_drivers )
   47394:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED

  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
}
   47396:	4e75           	rts                                               	<== NOT EXECUTED

    if ( !found )
      return RTEMS_TOO_MANY;
  }

  if ( _IO_Driver_address_table[major].initialization_entry ||
   47398:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4739a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4739c:	2479 0005 ac5e 	moveal 5ac5e <_IO_Driver_address_table>,%a2       	<== NOT EXECUTED
   473a2:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   473a4:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   473a6:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   473a8:	d5c0           	addal %d0,%a2                                     	<== NOT EXECUTED
   473aa:	4a92           	tstl %a2@                                         	<== NOT EXECUTED
   473ac:	671c           	beqs 473ca <rtems_io_register_driver+0xd2>        	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   473ae:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
}
   473b0:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   473b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   473b6:	4e75           	rts                                               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !registered_major )
    return RTEMS_INVALID_ADDRESS;

  if ( !driver_table->initialization_entry && !driver_table->open_entry )
   473b8:	4aa9 0004      	tstl %a1@(4)                                      	<== NOT EXECUTED
   473bc:	6600 ff60      	bnew 4731e <rtems_io_register_driver+0x26>        	<== NOT EXECUTED

  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
}
   473c0:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   473c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   473c6:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   473c8:	4e75           	rts                                               	<== NOT EXECUTED

    if ( !found )
      return RTEMS_TOO_MANY;
  }

  if ( _IO_Driver_address_table[major].initialization_entry ||
   473ca:	4aaa 0004      	tstl %a2@(4)                                      	<== NOT EXECUTED
   473ce:	6796           	beqs 47366 <rtems_io_register_driver+0x6e>        	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   473d0:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
   473d2:	60dc           	bras 473b0 <rtems_io_register_driver+0xb8>        	<== NOT EXECUTED

000473d4 <rtems_io_unregister_driver>:
 */

rtems_status_code rtems_io_unregister_driver(
  rtems_device_major_number major
)
{
   473d4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   473d8:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
  if ( major < _IO_Number_of_drivers ) {
   473dc:	b2b9 0005 ac5a 	cmpl 5ac5a <_IO_Number_of_drivers>,%d1            	<== NOT EXECUTED
   473e2:	6506           	bcss 473ea <rtems_io_unregister_driver+0x16>      	<== NOT EXECUTED
      sizeof( rtems_driver_address_table )
    );
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_UNSATISFIED;
}
   473e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

rtems_status_code rtems_io_unregister_driver(
  rtems_device_major_number major
)
{
  if ( major < _IO_Number_of_drivers ) {
   473e6:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
      sizeof( rtems_driver_address_table )
    );
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_UNSATISFIED;
}
   473e8:	4e75           	rts                                               	<== NOT EXECUTED
rtems_status_code rtems_io_unregister_driver(
  rtems_device_major_number major
)
{
  if ( major < _IO_Number_of_drivers ) {
    memset(
   473ea:	2079 0005 ac5e 	moveal 5ac5e <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   473f0:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   473f2:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   473f4:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   473f6:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   473f8:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
   473fa:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   473fc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   473fe:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   47400:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   47402:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   47404:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   47406:	4290           	clrl %a0@                                         	<== NOT EXECUTED
      sizeof( rtems_driver_address_table )
    );
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_UNSATISFIED;
}
   47408:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4740a:	4e75           	rts

0004c364 <rtems_io_write>:
rtems_status_code rtems_io_write(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4c364:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4c368:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4c36a:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4c36e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4c370:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4c374:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c378:	b4b9 0005 89ce 	cmpl 589ce <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4c37e:	642c           	bccs 4c3ac <rtems_io_write+0x48>                  	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].write_entry;
   4c380:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4c382:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4c384:	2079 0005 89d2 	moveal 589d2 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4c38a:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4c38c:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4c38e:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4c390:	2030 1810      	movel %a0@(00000010,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4c394:	6718           	beqs 4c3ae <rtems_io_write+0x4a>                  	<== NOT EXECUTED
   4c396:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4c39a:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4c39c:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4c3a0:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4c3a4:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c3a6:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c3a8:	4e5e           	unlk %fp                                          	<== 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;
   4c3aa:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
  void                      *argument
)
{
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4c3ac:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].write_entry;
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
   4c3ae:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4c3b0:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4c3b2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4c3b4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048304 <rtems_iterate_over_all_threads>:

#include <rtems/system.h>
#include <rtems/score/thread.h>

void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
   48304:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   48308:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   4830c:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
  uint32_t             i;
  uint32_t             api_index;
  Thread_Control      *the_thread;
  Objects_Information *information;

  if ( !routine )
   48310:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   48312:	6744           	beqs 48358 <rtems_iterate_over_all_threads+0x54>  	<== NOT EXECUTED
    return;
   48314:	47f9 0006 2d38 	lea 62d38 <_Objects_Information_table+0x4>,%a3    	<== NOT EXECUTED

  for ( api_index = 1 ;
        api_index <= OBJECTS_APIS_LAST ;
        api_index++ ) {
    if ( !_Objects_Information_table[ api_index ] )
   4831a:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
   4831c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4831e:	672e           	beqs 4834e <rtems_iterate_over_all_threads+0x4a>  	<== NOT EXECUTED
      continue;
    information = _Objects_Information_table[ api_index ][ 1 ];
   48320:	2468 0004      	moveal %a0@(4),%a2                                	<== NOT EXECUTED
    if ( information ) {
   48324:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   48326:	6726           	beqs 4834e <rtems_iterate_over_all_threads+0x4a>  	<== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {
   48328:	4a6a 000e      	tstw %a2@(14)                                     	<== NOT EXECUTED
   4832c:	6720           	beqs 4834e <rtems_iterate_over_all_threads+0x4a>  	<== NOT EXECUTED
   4832e:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
        the_thread = (Thread_Control *)information->local_table[ i ];
   48330:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   48334:	2030 2c00      	movel %a0@(00000000,%d2:l:4),%d0                  	<== 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++ ) {
   48338:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
        the_thread = (Thread_Control *)information->local_table[ i ];

        if ( !the_thread )
   4833a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4833c:	6706           	beqs 48344 <rtems_iterate_over_all_threads+0x40>  	<== NOT EXECUTED
          continue;

        (*routine)(the_thread);
   4833e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48340:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   48342:	588f           	addql #4,%sp                                      	<== 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++ ) {
   48344:	4280           	clrl %d0                                          	<== NOT EXECUTED
   48346:	302a 000e      	movew %a2@(14),%d0                                	<== NOT EXECUTED
   4834a:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   4834c:	63e2           	blss 48330 <rtems_iterate_over_all_threads+0x2c>  	<== NOT EXECUTED
   4834e:	588b           	addql #4,%a3                                      	<== NOT EXECUTED

  if ( !routine )
    return;

  for ( api_index = 1 ;
        api_index <= OBJECTS_APIS_LAST ;
   48350:	b7fc 0006 2d48 	cmpal #404808,%a3                                 	<== NOT EXECUTED
   48356:	66c2           	bnes 4831a <rtems_iterate_over_all_threads+0x16>  	<== NOT EXECUTED
        (*routine)(the_thread);
      }
    }
  }

}
   48358:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   4835e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48360:	4e75           	rts                                               	<== NOT EXECUTED
	...

000507e4 <rtems_message_queue_broadcast>:
  Objects_Id            id,
  const void           *buffer,
  size_t                size,
  uint32_t             *count
)
{
   507e4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   507e8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;
  CORE_message_queue_Status       core_status;

  if ( !buffer )
   507ea:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   507ee:	676c           	beqs 5085c <rtems_message_queue_broadcast+0x78>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !count )
   507f0:	4aae 0014      	tstl %fp@(20)                                     	<== NOT EXECUTED
   507f4:	6766           	beqs 5085c <rtems_message_queue_broadcast+0x78>   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   507f6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   507fa:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   507fe:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   50804:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   5080a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50810:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   50812:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50816:	663a           	bnes 50852 <rtems_message_queue_broadcast+0x6e>   	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      core_status = _CORE_message_queue_Broadcast(
   50818:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   5081c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5081e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50822:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   50826:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   5082a:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   5082e:	4eb9 0005 4108 	jsr 54108 <_CORE_message_queue_Broadcast>         	<== NOT EXECUTED
   50834:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
                        NULL,
                      #endif
                      count
                    );

      _Thread_Enable_dispatch();
   50836:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return
   5083c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5083e:	4eb9 0005 0be0 	jsr 50be0 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   50844:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
                      #endif
                      count
                    );

      _Thread_Enable_dispatch();
      return
   50848:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5084e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50850:	4e75           	rts                                               	<== NOT EXECUTED
   50852:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50856:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !count )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50858:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5085a:	4e75           	rts                                               	<== NOT EXECUTED
   5085c:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50860:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
                      #endif
                      count
                    );

      _Thread_Enable_dispatch();
      return
   50862:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   50864:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050868 <rtems_message_queue_create>:
  uint32_t            count,
  size_t              max_message_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   50868:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5086c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  CORE_message_queue_Attributes   the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
  bool                            is_global;
#endif

  if ( !rtems_is_name_valid( name ) )
   5086e:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   50872:	6728           	beqs 5089c <rtems_message_queue_create+0x34>      	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   50874:	4aae 0018      	tstl %fp@(24)                                     	<== NOT EXECUTED
   50878:	6700 009e      	beqw 50918 <rtems_message_queue_create+0xb0>      	<== NOT EXECUTED
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
       !_System_state_Is_multiprocessing )
    return RTEMS_MP_NOT_CONFIGURED;
#endif

  if ( count == 0 )
   5087c:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   50880:	6710           	beqs 50892 <rtems_message_queue_create+0x2a>      	<== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;

  if ( max_message_size == 0 )
   50882:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   50886:	661e           	bnes 508a6 <rtems_message_queue_create+0x3e>      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50888:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5088c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
#endif

  if ( count == 0 )
      return RTEMS_INVALID_NUMBER;

  if ( max_message_size == 0 )
   5088e:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50890:	4e75           	rts                                               	<== NOT EXECUTED
   50892:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50896:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
       !_System_state_Is_multiprocessing )
    return RTEMS_MP_NOT_CONFIGURED;
#endif

  if ( count == 0 )
   50898:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   5089a:	4e75           	rts                                               	<== NOT EXECUTED
   5089c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   508a0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  CORE_message_queue_Attributes   the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
  bool                            is_global;
#endif

  if ( !rtems_is_name_valid( name ) )
   508a2:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   508a4:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   508a6:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   508ac:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   508ae:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
#endif
#endif

  _Thread_Disable_dispatch();              /* protects object pointer */

  the_message_queue = _Message_queue_Allocate();
   508b4:	4eb9 0005 9700 	jsr 59700 <_Message_queue_Allocate>               	<== NOT EXECUTED
   508ba:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( !the_message_queue ) {
   508bc:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   508be:	6700 0092      	beqw 50952 <rtems_message_queue_create+0xea>      	<== NOT EXECUTED
#endif

  the_message_queue->attribute_set = attribute_set;

  if (_Attributes_Is_priority( attribute_set ) )
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
   508c2:	202e 0014      	movel %fp@(20),%d0                                	<== NOT EXECUTED
   508c6:	44c0           	movew %d0,%ccr                                    	<== NOT EXECUTED
   508c8:	56c0           	sne %d0                                           	<== NOT EXECUTED
   508ca:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   508cc:	204e           	moveal %fp,%a0                                    	<== NOT EXECUTED
   508ce:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   508d0:	2100           	movel %d0,%a0@-                                   	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_message_queue->attribute_set = attribute_set;
   508d2:	202e 0014      	movel %fp@(20),%d0                                	<== NOT EXECUTED
   508d6:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
  if (_Attributes_Is_priority( attribute_set ) )
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
  else
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;

  if ( ! _CORE_message_queue_Initialize(
   508da:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   508de:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   508e2:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   508e4:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   508e8:	4eb9 0005 4268 	jsr 54268 <_CORE_message_queue_Initialize>        	<== NOT EXECUTED
   508ee:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   508f4:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   508f6:	662a           	bnes 50922 <rtems_message_queue_create+0xba>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
  Message_queue_Control *the_message_queue
)
{
  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
   508f8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   508fa:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   50900:	4eb9 0005 5874 	jsr 55874 <_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();
   50906:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   5090c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
        _Objects_MP_Close(
          &_Message_queue_Information, the_message_queue->Object.id);
#endif

    _Message_queue_Free( the_message_queue );
    _Thread_Enable_dispatch();
   50910:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50912:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        _Objects_MP_Close(
          &_Message_queue_Information, the_message_queue->Object.id);
#endif

    _Message_queue_Free( the_message_queue );
    _Thread_Enable_dispatch();
   50914:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50916:	4e75           	rts                                               	<== NOT EXECUTED
   50918:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5091c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
#endif

  if ( !rtems_is_name_valid( name ) )
    return RTEMS_INVALID_NAME;

  if ( !id )
   5091e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50920:	4e75           	rts                                               	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   50922:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   50926:	2548 000c      	movel %a0,%a2@(12)                                	<== NOT EXECUTED
    &_Message_queue_Information,
    &the_message_queue->Object,
    (Objects_Name) name
  );

  *id = the_message_queue->Object.id;
   5092a:	206e 0018      	moveal %fp@(24),%a0                               	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   5092e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   50930:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   50934:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   50938:	2079 0007 1860 	moveal 71860 <_Message_queue_Information+0x1a>,%a0	<== NOT EXECUTED
   5093e:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
      name,
      0
    );
#endif

  _Thread_Enable_dispatch();
   50942:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50948:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5094c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      name,
      0
    );
#endif

  _Thread_Enable_dispatch();
   5094e:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50950:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();              /* protects object pointer */

  the_message_queue = _Message_queue_Allocate();

  if ( !the_message_queue ) {
    _Thread_Enable_dispatch();
   50952:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50958:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5095c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();              /* protects object pointer */

  the_message_queue = _Message_queue_Allocate();

  if ( !the_message_queue ) {
    _Thread_Enable_dispatch();
   5095e:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50960:	4e75           	rts                                               	<== NOT EXECUTED
	...

000526d8 <rtems_message_queue_delete>:
 */

rtems_status_code rtems_message_queue_delete(
  Objects_Id id
)
{
   526d8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   526dc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   526de:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   526e2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   526e6:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   526ec:	4eb9 0004 ccc8 	jsr 4ccc8 <_Objects_Get>                          	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   526f2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   526f8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   526fa:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   526fe:	6642           	bnes 52742 <rtems_message_queue_delete+0x6a>      	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Message_queue_Information,
   52700:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   52702:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   52708:	4eb9 0004 c838 	jsr 4c838 <_Objects_Close>                        	<== NOT EXECUTED
                      &the_message_queue->Object );

      _CORE_message_queue_Close(
   5270e:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   52712:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   52714:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   52718:	4eb9 0005 2d50 	jsr 52d50 <_CORE_message_queue_Close>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
  Message_queue_Control *the_message_queue
)
{
  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
   5271e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   52720:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   52726:	4eb9 0004 cb5c 	jsr 4cb5c <_Objects_Free>                         	<== NOT EXECUTED
          0,                                 /* Not used */
          0
        );
      }
#endif
      _Thread_Enable_dispatch();
   5272c:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52732:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
          0,                                 /* Not used */
          0
        );
      }
#endif
      _Thread_Enable_dispatch();
   52736:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5273c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          0,                                 /* Not used */
          0
        );
      }
#endif
      _Thread_Enable_dispatch();
   5273e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52740:	4e75           	rts                                               	<== NOT EXECUTED
   52742:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52746:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   52748:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5274a:	4e75           	rts

000509d8 <rtems_message_queue_flush>:

rtems_status_code rtems_message_queue_flush(
  Objects_Id  id,
  uint32_t   *count
)
{
   509d8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   509dc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   509de:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   509e2:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   509e4:	674a           	beqs 50a30 <rtems_message_queue_flush+0x58>       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   509e6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   509ea:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   509ee:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   509f4:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   509fa:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50a00:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   50a02:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50a06:	661e           	bnes 50a26 <rtems_message_queue_flush+0x4e>       	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
   50a08:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   50a0c:	4eb9 0005 41ec 	jsr 541ec <_CORE_message_queue_Flush>             	<== NOT EXECUTED
   50a12:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   50a14:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a1a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
      _Thread_Enable_dispatch();
   50a1e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
      _Thread_Enable_dispatch();
   50a22:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a24:	4e75           	rts                                               	<== NOT EXECUTED
   50a26:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50a2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !count )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50a2c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a2e:	4e75           	rts                                               	<== NOT EXECUTED
   50a30:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50a34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   50a36:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a38:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050a3c <rtems_message_queue_get_number_pending>:

rtems_status_code rtems_message_queue_get_number_pending(
  Objects_Id  id,
  uint32_t   *count
)
{
   50a3c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50a40:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   50a42:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   50a46:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   50a48:	6740           	beqs 50a8a <rtems_message_queue_get_number_pending+0x4e>	<== NOT EXECUTED
   50a4a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50a4e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50a52:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   50a58:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50a5e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50a64:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   50a66:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50a6a:	6614           	bnes 50a80 <rtems_message_queue_get_number_pending+0x44>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *count = the_message_queue->message_queue.number_of_pending_messages;
   50a6c:	24a8 005c      	movel %a0@(92),%a2@                               	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   50a70:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a76:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50a7a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *count = the_message_queue->message_queue.number_of_pending_messages;
      _Thread_Enable_dispatch();
   50a7c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a7e:	4e75           	rts                                               	<== NOT EXECUTED
   50a80:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50a84:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !count )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50a86:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a88:	4e75           	rts                                               	<== NOT EXECUTED
   50a8a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50a8e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   50a90:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50a92:	4e75           	rts

0005274c <rtems_message_queue_ident>:
rtems_status_code rtems_message_queue_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   5274c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   52750:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   52754:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52758:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5275c:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   52762:	4eb9 0004 ce60 	jsr 4ce60 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   52768:	41f9 0006 2094 	lea 62094 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    node,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   5276e:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   52772:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   52774:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052778 <rtems_message_queue_receive>:
  void                 *buffer,
  size_t               *size,
  rtems_option          option_set,
  rtems_interval        timeout
)
{
   52778:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   5277c:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   52780:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   52784:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   52788:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;
  bool                            wait;

  if ( !buffer )
   5278c:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   5278e:	6776           	beqs 52806 <rtems_message_queue_receive+0x8e>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !size )
   52790:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   52792:	6772           	beqs 52806 <rtems_message_queue_receive+0x8e>     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   52794:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52798:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5279c:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   527a2:	4eb9 0004 ccc8 	jsr 4ccc8 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   527a8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   527ae:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   527b0:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   527b4:	6644           	bnes 527fa <rtems_message_queue_receive+0x82>     	<== NOT EXECUTED
      if ( _Options_Is_no_wait( option_set ) )
        wait = false;
      else
        wait = true;

      _CORE_message_queue_Seize(
   527b6:	2f2e 0018      	movel %fp@(24),%sp@-                              	<== NOT EXECUTED
   527ba:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   527bc:	b182           	eorl %d0,%d2                                      	<== NOT EXECUTED
   527be:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   527c0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   527c2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   527c4:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   527c6:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   527ca:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   527ce:	4eb9 0005 2e00 	jsr 52e00 <_CORE_message_queue_Seize>             	<== NOT EXECUTED
        buffer,
        size,
        wait,
        timeout
      );
      _Thread_Enable_dispatch();
   527d4:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return _Message_queue_Translate_core_message_queue_return_code(
   527da:	2079 0006 6c9a 	moveal 66c9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   527e0:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   527e4:	4eb9 0005 2898 	jsr 52898 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
   527ea:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   527f0:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   527f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   527f8:	4e75           	rts                                               	<== NOT EXECUTED
   527fa:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   52800:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !size )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   52802:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52804:	4e75           	rts                                               	<== NOT EXECUTED
   52806:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   5280c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        size,
        wait,
        timeout
      );
      _Thread_Enable_dispatch();
      return _Message_queue_Translate_core_message_queue_return_code(
   5280e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52810:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052814 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
  Objects_Id            id,
  const void           *buffer,
  size_t                size
)
{
   52814:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   52818:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   5281a:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   5281e:	676e           	beqs 5288e <rtems_message_queue_send+0x7a>        	<== NOT EXECUTED
   52820:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52824:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52828:	4879 0006 6e82 	pea 66e82 <_Message_queue_Information>            	<== NOT EXECUTED
   5282e:	4eb9 0004 ccc8 	jsr 4ccc8 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   52834:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5283a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   5283c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   52840:	6642           	bnes 52884 <rtems_message_queue_send+0x70>        	<== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,
  Watchdog_Interval                          timeout
)
{
  return _CORE_message_queue_Submit(
   52842:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   52844:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   52846:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   5284c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5284e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52852:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   52856:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   5285a:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   5285e:	4eb9 0005 2f3c 	jsr 52f3c <_CORE_message_queue_Submit>            	<== NOT EXECUTED
        MESSAGE_QUEUE_MP_HANDLER,
        FALSE,   /* sender does not block */
        0        /* no timeout */
      );

      _Thread_Enable_dispatch();
   52864:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   5286a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5286c:	4eb9 0004 d5bc 	jsr 4d5bc <_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);
   52872:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52874:	4eb9 0005 2898 	jsr 52898 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5287a:	242e fff8      	movel %fp@(-8),%d2                                	<== 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);
   5287e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   52880:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   52882:	4e75           	rts                                               	<== NOT EXECUTED
   52884:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   52888:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !buffer )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   5288a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5288c:	4e75           	rts                                               	<== NOT EXECUTED
   5288e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   52892:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   52894:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   52896:	4e75           	rts

00050bf8 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
  Objects_Id            id,
  const void           *buffer,
  size_t                size
)
{
   50bf8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50bfc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   50bfe:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   50c02:	676e           	beqs 50c72 <rtems_message_queue_urgent+0x7a>      	<== NOT EXECUTED
   50c04:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50c08:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50c0c:	4879 0007 1846 	pea 71846 <_Message_queue_Information>            	<== NOT EXECUTED
   50c12:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50c18:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50c1e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   50c20:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50c24:	6642           	bnes 50c68 <rtems_message_queue_urgent+0x70>      	<== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,
  Watchdog_Interval                          timeout
)
{
  return _CORE_message_queue_Submit(
   50c26:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   50c28:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   50c2a:	2f3c 8000 0000 	movel #-2147483648,%sp@-                          	<== NOT EXECUTED
   50c30:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   50c32:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50c36:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   50c3a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   50c3e:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   50c42:	4eb9 0005 446c 	jsr 5446c <_CORE_message_queue_Submit>            	<== NOT EXECUTED
        id,
        MESSAGE_QUEUE_MP_HANDLER,
        FALSE,   /* sender does not block */
        0        /* no timeout */
      );
      _Thread_Enable_dispatch();
   50c48:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   50c4e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   50c50:	4eb9 0005 62a4 	jsr 562a4 <_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);
   50c56:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   50c58:	4eb9 0005 0be0 	jsr 50be0 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50c5e:	242e fff8      	movel %fp@(-8),%d2                                	<== 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);
   50c62:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50c64:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50c66:	4e75           	rts                                               	<== NOT EXECUTED
   50c68:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50c6c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !buffer )
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   50c6e:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50c70:	4e75           	rts                                               	<== NOT EXECUTED
   50c72:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50c76:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   50c78:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50c7a:	4e75           	rts

00047134 <rtems_object_api_maximum_class>:
#include <rtems/rtems/types.h>

int rtems_object_api_maximum_class(
  uint32_t api
)
{
   47134:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_API_maximum_class(api);
}
   47138:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

int rtems_object_api_maximum_class(
  uint32_t api
)
{
  return _Objects_API_maximum_class(api);
   4713a:	4ef9 0004 8a04 	jmp 48a04 <_Objects_API_maximum_class>            	<== NOT EXECUTED

00047140 <rtems_object_api_minimum_class>:
#include <rtems/rtems/types.h>

uint32_t rtems_object_api_minimum_class(
  uint32_t api
)
{
   47140:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   47144:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   47148:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4714a:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4714c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4714e:	55c0           	scs %d0                                           	<== NOT EXECUTED
   47150:	49c0           	extbl %d0                                         	<== NOT EXECUTED
  if ( _Objects_Is_api_valid( api ) )
    return 1;
  return -1;
}
   47152:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   47156:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47158:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4715a:	4e75           	rts

0004715c <rtems_object_get_api_class_name>:

const char *rtems_object_get_api_class_name(
  uint32_t the_api,
  uint32_t the_class
)
{
   4715c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47160:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   47164:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  const rtems_assoc_t *api_assoc;
  const rtems_assoc_t *class_assoc;

  if ( the_api == OBJECTS_INTERNAL_API )
   47166:	203c 0005 a894 	movel #370836,%d0                                 	<== NOT EXECUTED
   4716c:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4716e:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   47170:	671a           	beqs 4718c <rtems_object_get_api_class_name+0x30> 	<== NOT EXECUTED
    api_assoc = rtems_object_api_internal_assoc;
  else if ( the_api == OBJECTS_CLASSIC_API )
   47172:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
   47174:	203c 0005 9313 	movel #365331,%d0                                 	<== NOT EXECUTED
   4717a:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   4717c:	6708           	beqs 47186 <rtems_object_get_api_class_name+0x2a> 	<== NOT EXECUTED
    return "BAD API";
  class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
  if ( class_assoc )
    return class_assoc->name;
  return "BAD CLASS";
}
   4717e:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   47182:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47184:	4e75           	rts                                               	<== NOT EXECUTED
  const rtems_assoc_t *api_assoc;
  const rtems_assoc_t *class_assoc;

  if ( the_api == OBJECTS_INTERNAL_API )
    api_assoc = rtems_object_api_internal_assoc;
  else if ( the_api == OBJECTS_CLASSIC_API )
   47186:	203c 0005 a8ac 	movel #370860,%d0                                 	<== 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 );
   4718c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   47190:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47192:	4eb9 0004 bdbc 	jsr 4bdbc <rtems_assoc_ptr_by_local>              	<== NOT EXECUTED
   47198:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( class_assoc )
   4719a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4719c:	203c 0005 931b 	movel #365339,%d0                                 	<== NOT EXECUTED
   471a2:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   471a4:	67d8           	beqs 4717e <rtems_object_get_api_class_name+0x22> 	<== NOT EXECUTED
    return class_assoc->name;
  return "BAD CLASS";
}
   471a6:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
#endif
  else
    return "BAD API";
  class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
  if ( class_assoc )
    return class_assoc->name;
   471aa:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
  return "BAD CLASS";
}
   471ac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   471ae:	4e75           	rts

000471b0 <rtems_object_get_api_name>:
};

const char *rtems_object_get_api_name(
  uint32_t api
)
{
   471b0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  const rtems_assoc_t *api_assoc;

  api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
   471b4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   471b8:	4879 0005 a924 	pea 5a924 <rtems_objects_api_assoc>               	<== NOT EXECUTED
   471be:	4eb9 0004 bdbc 	jsr 4bdbc <rtems_assoc_ptr_by_local>              	<== NOT EXECUTED
   471c4:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( api_assoc )
   471c6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   471c8:	203c 0005 931b 	movel #365339,%d0                                 	<== NOT EXECUTED
   471ce:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   471d0:	6702           	beqs 471d4 <rtems_object_get_api_name+0x24>       	<== NOT EXECUTED
    return api_assoc->name;
   471d2:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
  return "BAD CLASS";
}
   471d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   471d6:	4e75           	rts

00047218 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
  uint32_t                            the_api,
  uint32_t                            the_class,
  rtems_object_api_class_information *info
)
{
   47218:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4721c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4721e:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
  uint32_t             i;

  /*
   * Validate parameters and look up information structure.
   */
  if ( !info )
   47222:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   47224:	6762           	beqs 47288 <rtems_object_get_class_information+0x70>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  obj_info = _Objects_Get_information( the_api, the_class );
   47226:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4722a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4722e:	4eb9 0004 8e1c 	jsr 48e1c <_Objects_Get_information>              	<== NOT EXECUTED
  if ( !obj_info )
   47234:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   * Validate parameters and look up information structure.
   */
  if ( !info )
    return RTEMS_INVALID_ADDRESS;

  obj_info = _Objects_Get_information( the_api, the_class );
   47236:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( !obj_info )
   47238:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4723a:	6756           	beqs 47292 <rtems_object_get_class_information+0x7a>	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  /*
   * Return information about this object class to the user.
   */
  info->minimum_id  = obj_info->minimum_id;
   4723c:	24a8 0006      	movel %a0@(6),%a2@                                	<== NOT EXECUTED
  info->maximum_id  = obj_info->maximum_id;
  info->auto_extend = obj_info->auto_extend;
  info->maximum     = obj_info->maximum;
   47240:	4281           	clrl %d1                                          	<== NOT EXECUTED

  /*
   * Return information about this object class to the user.
   */
  info->minimum_id  = obj_info->minimum_id;
  info->maximum_id  = obj_info->maximum_id;
   47242:	2568 000a 0004 	movel %a0@(10),%a2@(4)                            	<== NOT EXECUTED
  info->auto_extend = obj_info->auto_extend;
  info->maximum     = obj_info->maximum;
   47248:	3228 000e      	movew %a0@(14),%d1                                	<== NOT EXECUTED
   4724c:	2541 0008      	movel %d1,%a2@(8)                                 	<== NOT EXECUTED
  /*
   * Return information about this object class to the user.
   */
  info->minimum_id  = obj_info->minimum_id;
  info->maximum_id  = obj_info->maximum_id;
  info->auto_extend = obj_info->auto_extend;
   47250:	1568 0010 000c 	moveb %a0@(16),%a2@(12)                           	<== NOT EXECUTED
  info->maximum     = obj_info->maximum;

  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
   47256:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   47258:	6742           	beqs 4729c <rtems_object_get_class_information+0x84>	<== NOT EXECUTED
   4725a:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   4725e:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   47260:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   47262:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47264:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
    if ( !obj_info->local_table[i] )
   47266:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   47268:	6714           	beqs 4727e <rtems_object_get_class_information+0x66>	<== 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++ )
   4726a:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   4726c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4726e:	63f4           	blss 47264 <rtems_object_get_class_information+0x4c>	<== NOT EXECUTED
    if ( !obj_info->local_table[i] )
      unallocated++;

  info->unallocated = unallocated;
   47270:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47272:	2549 000e      	movel %a1,%a2@(14)                                	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   47276:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4727a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4727c:	4e75           	rts                                               	<== NOT EXECUTED
  info->auto_extend = obj_info->auto_extend;
  info->maximum     = obj_info->maximum;

  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
    if ( !obj_info->local_table[i] )
      unallocated++;
   4727e:	5289           	addql #1,%a1                                      	<== 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++ )
   47280:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   47282:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47284:	63de           	blss 47264 <rtems_object_get_class_information+0x4c>	<== NOT EXECUTED
   47286:	60e8           	bras 47270 <rtems_object_get_class_information+0x58>	<== NOT EXECUTED
      unallocated++;

  info->unallocated = unallocated;

  return RTEMS_SUCCESSFUL;
}
   47288:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4728c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  uint32_t             i;

  /*
   * Validate parameters and look up information structure.
   */
  if ( !info )
   4728e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
      unallocated++;

  info->unallocated = unallocated;

  return RTEMS_SUCCESSFUL;
}
   47290:	4e75           	rts                                               	<== NOT EXECUTED
   47292:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47296:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */
  if ( !info )
    return RTEMS_INVALID_ADDRESS;

  obj_info = _Objects_Get_information( the_api, the_class );
  if ( !obj_info )
   47298:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
      unallocated++;

  info->unallocated = unallocated;

  return RTEMS_SUCCESSFUL;
}
   4729a:	4e75           	rts                                               	<== 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++ )
   4729c:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
    if ( !obj_info->local_table[i] )
      unallocated++;

  info->unallocated = unallocated;
   4729e:	2549 000e      	movel %a1,%a2@(14)                                	<== NOT EXECUTED
   472a2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   472a4:	60d0           	bras 47276 <rtems_object_get_class_information+0x5e>	<== NOT EXECUTED
	...

000468a4 <rtems_object_get_classic_name>:

rtems_status_code rtems_object_get_classic_name(
  rtems_id      id,
  rtems_name   *name
)
{
   468a4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   468a8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   468aa:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;
  Objects_Name                      name_u;

  if ( !name )
   468ae:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   468b0:	6726           	beqs 468d8 <rtems_object_get_classic_name+0x34>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  status = _Objects_Id_to_name( id, &name_u );
   468b2:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   468b6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   468ba:	4eb9 0004 8504 	jsr 48504 <_Objects_Id_to_name>                   	<== NOT EXECUTED

  *name = name_u.name_u32;
   468c0:	24ae fffc      	movel %fp@(-4),%a2@                               	<== NOT EXECUTED
  return _Status_Object_name_errors_to_status[ status ];
   468c4:	41f9 0005 8094 	lea 58094 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
}
   468ca:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  status = _Objects_Id_to_name( id, &name_u );

  *name = name_u.name_u32;
  return _Status_Object_name_errors_to_status[ status ];
   468ce:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   468d2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   468d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   468d6:	4e75           	rts                                               	<== NOT EXECUTED
   468d8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   468dc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Objects_Name_or_id_lookup_errors  status;
  Objects_Name                      name_u;

  if ( !name )
   468de:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

  status = _Objects_Id_to_name( id, &name_u );

  *name = name_u.name_u32;
  return _Status_Object_name_errors_to_status[ status ];
}
   468e0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052940 <rtems_object_get_name>:
char *rtems_object_get_name(
  Objects_Id     id,
  size_t         length,
  char          *name
)
{
   52940:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_name_as_string( id, length, name );
}
   52944:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id     id,
  size_t         length,
  char          *name
)
{
  return _Objects_Get_name_as_string( id, length, name );
   52946:	4ef9 0005 3488 	jmp 53488 <_Objects_Get_name_as_string>           	<== NOT EXECUTED

000472b4 <rtems_object_id_api_maximum>:
#include <rtems/score/object.h>
#include <rtems/rtems/types.h>

#undef rtems_object_id_api_maximum
uint32_t rtems_object_id_api_maximum(void)
{
   472b4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return OBJECTS_ITRON_API;
}
   472b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472ba:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   472bc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472c0 <rtems_object_id_api_minimum>:
#include <rtems/score/object.h>
#include <rtems/rtems/types.h>

#undef rtems_object_id_api_minimum
uint32_t rtems_object_id_api_minimum(void)
{
   472c0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return OBJECTS_INTERNAL_API;
}
   472c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472c6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   472c8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472cc <rtems_object_id_get_api>:

#undef rtems_object_id_get_api
uint32_t rtems_object_id_get_api(
  rtems_id id
)
{
   472cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   472d0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   472d2:	102e 0008      	moveb %fp@(8),%d0                                 	<== NOT EXECUTED
  return _Objects_Get_API( id );
}
   472d6:	7207           	moveq #7,%d1                                      	<== NOT EXECUTED
   472d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472da:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   472dc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472e0 <rtems_object_id_get_class>:

#undef rtems_object_id_get_class
uint32_t rtems_object_id_get_class(
  rtems_id id
)
{
   472e0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   472e4:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  return _Objects_Get_class( id );
}
   472e8:	721b           	moveq #27,%d1                                     	<== NOT EXECUTED
   472ea:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472ec:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   472ee:	4e75           	rts

000472f0 <rtems_object_id_get_index>:

#undef rtems_object_id_get_index
uint32_t rtems_object_id_get_index(
  rtems_id id
)
{
   472f0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_index( id );
}
   472f4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   472f6:	302e 000a      	movew %fp@(10),%d0                                	<== NOT EXECUTED
   472fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472fc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047300 <rtems_object_id_get_node>:

#undef rtems_object_id_get_node
uint32_t rtems_object_id_get_node(
  rtems_id id
)
{
   47300:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_node( id );
}
   47304:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47306:	102e 0009      	moveb %fp@(9),%d0                                 	<== NOT EXECUTED
   4730a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4730c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047310 <rtems_object_set_name>:
 */
rtems_status_code rtems_object_set_name(
  rtems_id       id,
  const char    *name
)
{
   47310:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   47314:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47316:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4731a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Information *information;
  Objects_Locations    location;
  Objects_Control     *the_object;
  Objects_Id           tmpId;

  if ( !name )
   4731c:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   47320:	677c           	beqs 4739e <rtems_object_set_name+0x8e>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   47322:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47324:	665a           	bnes 47380 <rtems_object_set_name+0x70>           	<== NOT EXECUTED
   47326:	2079 0005 c0ba 	moveal 5c0ba <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4732c:	2428 0008      	movel %a0@(8),%d2                                 	<== NOT EXECUTED

  information  = _Objects_Get_information_id( tmpId );
   47330:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47332:	4eb9 0004 8df0 	jsr 48df0 <_Objects_Get_information_id>           	<== NOT EXECUTED
  if ( !information )
   47338:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  if ( !name )
    return RTEMS_INVALID_ADDRESS;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;

  information  = _Objects_Get_information_id( tmpId );
   4733a:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  if ( !information )
   4733c:	6752           	beqs 47390 <rtems_object_set_name+0x80>           	<== NOT EXECUTED
    return RTEMS_INVALID_ID;

  the_object = _Objects_Get( information, tmpId, &location );
   4733e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   47342:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47344:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47346:	4eb9 0004 8fdc 	jsr 48fdc <_Objects_Get>                          	<== NOT EXECUTED
  switch ( location ) {
   4734c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47352:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   47356:	6638           	bnes 47390 <rtems_object_set_name+0x80>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Set_name( information, the_object, name );
   47358:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4735c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4735e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47360:	4eb9 0004 9240 	jsr 49240 <_Objects_Set_name>                     	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   47366:	4eb9 0004 99ac 	jsr 499ac <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4736c:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   47370:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
  the_object = _Objects_Get( information, tmpId, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Objects_Set_name( information, the_object, name );
      _Thread_Enable_dispatch();
   47374:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4737a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_object = _Objects_Get( information, tmpId, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Objects_Set_name( information, the_object, name );
      _Thread_Enable_dispatch();
   4737c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4737e:	4e75           	rts                                               	<== NOT EXECUTED
  Objects_Id           tmpId;

  if ( !name )
    return RTEMS_INVALID_ADDRESS;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   47380:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED

  information  = _Objects_Get_information_id( tmpId );
   47382:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47384:	4eb9 0004 8df0 	jsr 48df0 <_Objects_Get_information_id>           	<== NOT EXECUTED
  if ( !information )
   4738a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  if ( !name )
    return RTEMS_INVALID_ADDRESS;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;

  information  = _Objects_Get_information_id( tmpId );
   4738c:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  if ( !information )
   4738e:	66ae           	bnes 4733e <rtems_object_set_name+0x2e>           	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47390:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   47394:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   47398:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Objects_Set_name( information, the_object, name );
      _Thread_Enable_dispatch();
      return RTEMS_SUCCESSFUL;
   4739a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4739c:	4e75           	rts                                               	<== NOT EXECUTED
   4739e:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   473a2:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   473a6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Information *information;
  Objects_Locations    location;
  Objects_Control     *the_object;
  Objects_Id           tmpId;

  if ( !name )
   473a8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   473aa:	4e75           	rts

00050c7c <rtems_partition_create>:
  uint32_t            length,
  uint32_t            buffer_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   50c7c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   50c80:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   50c82:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Partition_Control *the_partition;

  if ( !rtems_is_name_valid( name ) )
   50c84:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   50c88:	6750           	beqs 50cda <rtems_partition_create+0x5e>          	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !starting_address )
   50c8a:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   50c8e:	672e           	beqs 50cbe <rtems_partition_create+0x42>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !id )
   50c90:	4aae 001c      	tstl %fp@(28)                                     	<== NOT EXECUTED
   50c94:	6728           	beqs 50cbe <rtems_partition_create+0x42>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( length == 0 || buffer_size == 0 || length < buffer_size ||
   50c96:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   50c9a:	6730           	beqs 50ccc <rtems_partition_create+0x50>          	<== NOT EXECUTED
   50c9c:	4aae 0014      	tstl %fp@(20)                                     	<== NOT EXECUTED
   50ca0:	672a           	beqs 50ccc <rtems_partition_create+0x50>          	<== NOT EXECUTED
   50ca2:	202e 0014      	movel %fp@(20),%d0                                	<== NOT EXECUTED
   50ca6:	b0ae 0010      	cmpl %fp@(16),%d0                                 	<== NOT EXECUTED
   50caa:	6220           	bhis 50ccc <rtems_partition_create+0x50>          	<== NOT EXECUTED
   50cac:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   50cae:	c0ae 0014      	andl %fp@(20),%d0                                 	<== NOT EXECUTED
   50cb2:	6618           	bnes 50ccc <rtems_partition_create+0x50>          	<== NOT EXECUTED
         !_Partition_Is_buffer_size_aligned( buffer_size ) )
    return RTEMS_INVALID_SIZE;

  if ( !_Addresses_Is_aligned( starting_address ) )
   50cb4:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   50cb8:	c0ae 000c      	andl %fp@(12),%d0                                 	<== NOT EXECUTED
   50cbc:	672a           	beqs 50ce8 <rtems_partition_create+0x6c>          	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50cbe:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50cc2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   50cc6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   50cc8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   50cca:	4e75           	rts                                               	<== NOT EXECUTED
   50ccc:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50cd0:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   50cd4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   50cd6:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
}
   50cd8:	4e75           	rts                                               	<== NOT EXECUTED
   50cda:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50cde:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   50ce2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id         *id
)
{
  register Partition_Control *the_partition;

  if ( !rtems_is_name_valid( name ) )
   50ce4:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50ce6:	4e75           	rts                                               	<== NOT EXECUTED
   50ce8:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   50cee:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   50cf0:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  This function allocates a partition control block from
 *  the inactive chain of free partition control blocks.
 */
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
  return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
   50cf6:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50cfc:	4eb9 0005 54b4 	jsr 554b4 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();               /* prevents deletion */

  the_partition = _Partition_Allocate();

  if ( !the_partition ) {
   50d02:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   50d04:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50d06:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   50d08:	6770           	beqs 50d7a <rtems_partition_create+0xfe>          	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }
#endif

  the_partition->starting_address      = starting_address;
  the_partition->length                = length;
   50d0a:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
  the_partition->buffer_size           = buffer_size;
  the_partition->attribute_set         = attribute_set;
   50d0e:	256e 0018 001c 	movel %fp@(24),%a2@(28)                           	<== NOT EXECUTED
  the_partition->number_of_used_blocks = 0;

  _Chain_Initialize( &the_partition->Memory, starting_address,
   50d14:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_partition->starting_address      = starting_address;
   50d18:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  the_partition->length                = length;
   50d1c:	2541 0014      	movel %d1,%a2@(20)                                	<== NOT EXECUTED
  the_partition->buffer_size           = buffer_size;
  the_partition->attribute_set         = attribute_set;
  the_partition->number_of_used_blocks = 0;

  _Chain_Initialize( &the_partition->Memory, starting_address,
   50d20:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_partition->starting_address      = starting_address;
   50d24:	2548 0010      	movel %a0,%a2@(16)                                	<== NOT EXECUTED
  the_partition->length                = length;
  the_partition->buffer_size           = buffer_size;
   50d28:	2542 0018      	movel %d2,%a2@(24)                                	<== NOT EXECUTED
  the_partition->attribute_set         = attribute_set;
  the_partition->number_of_used_blocks = 0;
   50d2c:	42aa 0020      	clrl %a2@(32)                                     	<== NOT EXECUTED

  _Chain_Initialize( &the_partition->Memory, starting_address,
   50d30:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   50d32:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   50d34:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   50d36:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   50d3a:	4eb9 0005 40a8 	jsr 540a8 <_Chain_Initialize>                     	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   50d40:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   50d44:	2079 0007 1446 	moveal 71446 <_Partition_Information+0x1a>,%a0    	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   50d4a:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   50d4e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   50d50:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   50d54:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    &_Partition_Information,
    &the_partition->Object,
    (Objects_Name) name
  );

  *id = the_partition->Object.id;
   50d58:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
   50d5c:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
      name,
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
   50d60:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50d66:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50d6a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
      name,
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
   50d6e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50d74:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      name,
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
   50d76:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50d78:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();               /* prevents deletion */

  the_partition = _Partition_Allocate();

  if ( !the_partition ) {
    _Thread_Enable_dispatch();
   50d7a:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50d80:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   50d84:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   50d88:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();               /* prevents deletion */

  the_partition = _Partition_Allocate();

  if ( !the_partition ) {
    _Thread_Enable_dispatch();
   50d8a:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
    );
#endif

  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50d8c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050d90 <rtems_partition_delete>:
 */

rtems_status_code rtems_partition_delete(
  Objects_Id id
)
{
   50d90:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50d94:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   50d96:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50d9a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50d9e:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50da4:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50daa:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50db0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50db2:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50db6:	670a           	beqs 50dc2 <rtems_partition_delete+0x32>          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50db8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50dbc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50dbe:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50dc0:	4e75           	rts                                               	<== NOT EXECUTED

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( the_partition->number_of_used_blocks == 0 ) {
   50dc2:	4aaa 0020      	tstl %a2@(32)                                     	<== NOT EXECUTED
   50dc6:	6710           	beqs 50dd8 <rtems_partition_delete+0x48>          	<== NOT EXECUTED
#endif

        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50dc8:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50dce:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50dd2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
#endif

        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50dd4:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50dd6:	4e75           	rts                                               	<== NOT EXECUTED
  the_partition = _Partition_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( the_partition->number_of_used_blocks == 0 ) {
        _Objects_Close( &_Partition_Information, &the_partition->Object );
   50dd8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   50dda:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50de0:	4eb9 0005 5550 	jsr 55550 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Partition_Free (
   Partition_Control *the_partition
)
{
  _Objects_Free( &_Partition_Information, &the_partition->Object );
   50de6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   50de8:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50dee:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
            0                          /* Not used */
          );
        }
#endif

        _Thread_Enable_dispatch();
   50df4:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50dfa:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
            0                          /* Not used */
          );
        }
#endif

        _Thread_Enable_dispatch();
   50dfe:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e04:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
            0                          /* Not used */
          );
        }
#endif

        _Thread_Enable_dispatch();
   50e06:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e08:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050e0c <rtems_partition_get_buffer>:

rtems_status_code rtems_partition_get_buffer(
  Objects_Id   id,
  void       **buffer
)
{
   50e0c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50e10:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   50e12:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;
  void                       *the_buffer;

  if ( !buffer )
   50e14:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   50e18:	675e           	beqs 50e78 <rtems_partition_get_buffer+0x6c>      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   50e1a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50e1e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50e22:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50e28:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50e2e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50e34:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50e36:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50e3a:	662e           	bnes 50e6a <rtems_partition_get_buffer+0x5e>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
   Partition_Control *the_partition
)
{
  return _Chain_Get( &the_partition->Memory );
   50e3c:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   50e40:	4eb9 0005 406c 	jsr 5406c <_Chain_Get>                            	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_buffer = _Partition_Allocate_buffer( the_partition );
      if ( the_buffer ) {
   50e46:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   50e48:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   50e4a:	673a           	beqs 50e86 <rtems_partition_get_buffer+0x7a>      	<== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;
   50e4c:	52aa 0020      	addql #1,%a2@(32)                                 	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   50e50:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
        *buffer = the_buffer;
   50e56:	4280           	clrl %d0                                          	<== NOT EXECUTED
   50e58:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   50e5c:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e5e:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   50e62:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50e66:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50e68:	4e75           	rts                                               	<== NOT EXECUTED
   50e6a:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   50e6e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50e72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !buffer )
    return RTEMS_INVALID_ADDRESS;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50e74:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e76:	4e75           	rts                                               	<== NOT EXECUTED
   50e78:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   50e7c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50e80:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Partition_Control *the_partition;
  Objects_Locations           location;
  void                       *the_buffer;

  if ( !buffer )
   50e82:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e84:	4e75           	rts                                               	<== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;
        _Thread_Enable_dispatch();
        *buffer = the_buffer;
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50e86:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e8c:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   50e90:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50e94:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;
        _Thread_Enable_dispatch();
        *buffer = the_buffer;
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50e96:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50e98:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050e9c <rtems_partition_ident>:
rtems_status_code rtems_partition_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   50e9c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32( &_Partition_Information, name, node, id );
   50ea0:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   50ea4:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   50ea8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50eac:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50eb2:	4eb9 0005 5bb8 	jsr 55bb8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   50eb8:	41f9 0006 a75e 	lea 6a75e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
}
   50ebe:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   50ec2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50ec4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050ec8 <rtems_partition_return_buffer>:

rtems_status_code rtems_partition_return_buffer(
  Objects_Id  id,
  void       *buffer
)
{
   50ec8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50ecc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   50ece:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50ed2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50ed6:	4879 0007 142c 	pea 7142c <_Partition_Information>                	<== NOT EXECUTED
   50edc:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50ee2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50ee8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50eea:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50eee:	670a           	beqs 50efa <rtems_partition_return_buffer+0x32>   	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50ef0:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50ef4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   50ef6:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50ef8:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  void *starting;
  void *ending;

  starting = the_partition->starting_address;
   50efa:	222a 0010      	movel %a2@(16),%d1                                	<== NOT EXECUTED
  ending   = _Addresses_Add_offset( starting, the_partition->length );
   50efe:	202a 0014      	movel %a2@(20),%d0                                	<== NOT EXECUTED
  void *address,
  void *base,
  void *limit
)
{
  return (address >= base && address <= limit);
   50f02:	b2ae 000c      	cmpl %fp@(12),%d1                                 	<== NOT EXECUTED
   50f06:	6310           	blss 50f18 <rtems_partition_return_buffer+0x50>   	<== NOT EXECUTED
        _Partition_Free_buffer( the_partition, buffer );
        the_partition->number_of_used_blocks -= 1;
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50f08:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f0e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50f12:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        _Partition_Free_buffer( the_partition, buffer );
        the_partition->number_of_used_blocks -= 1;
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   50f14:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f16:	4e75           	rts                                               	<== NOT EXECUTED
   50f18:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   50f1a:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   50f1e:	65e8           	bcss 50f08 <rtems_partition_return_buffer+0x40>   	<== NOT EXECUTED

  return (
   50f20:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   50f24:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   50f26:	4c6a 0001 0018 	remul %a2@(24),%d1,%d0                            	<== NOT EXECUTED
   50f2c:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   50f2e:	66d8           	bnes 50f08 <rtems_partition_return_buffer+0x40>   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
  Partition_Control *the_partition,
  Chain_Node        *the_buffer
)
{
  _Chain_Append( &the_partition->Memory, the_buffer );
   50f30:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   50f34:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   50f38:	4eb9 0005 4034 	jsr 54034 <_Chain_Append>                         	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
        _Partition_Free_buffer( the_partition, buffer );
        the_partition->number_of_used_blocks -= 1;
   50f3e:	53aa 0020      	subql #1,%a2@(32)                                 	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   50f42:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f48:	246e fff8      	moveal %fp@(-8),%a2                               	<== 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;
        _Thread_Enable_dispatch();
   50f4c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f4e:	4e5e           	unlk %fp                                          	<== 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;
        _Thread_Enable_dispatch();
   50f50:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f52:	4e75           	rts

0005019c <rtems_port_create>:
  void         *internal_start,
  void         *external_start,
  uint32_t      length,
  Objects_Id   *id
)
{
   5019c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;

  if ( !rtems_is_name_valid( name) )
   501a0:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   501a4:	671a           	beqs 501c0 <rtems_port_create+0x24>               	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   501a6:	4aae 0018      	tstl %fp@(24)                                     	<== NOT EXECUTED
   501aa:	670e           	beqs 501ba <rtems_port_create+0x1e>               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_Addresses_Is_aligned( internal_start ) ||
   501ac:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   501b0:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   501b2:	80ae 000c      	orl %fp@(12),%d0                                  	<== NOT EXECUTED
   501b6:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   501b8:	670c           	beqs 501c6 <rtems_port_create+0x2a>               	<== NOT EXECUTED
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   501ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    (Objects_Name) name
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   501bc:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   501be:	4e75           	rts                                               	<== NOT EXECUTED
   501c0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id   *id
)
{
  register Dual_ported_memory_Control *the_port;

  if ( !rtems_is_name_valid( name) )
   501c2:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   501c4:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   501c6:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   501cc:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   501ce:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  of free port control blocks.
 */
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
   *_Dual_ported_memory_Allocate ( void )
{
  return (Dual_ported_memory_Control *)
   501d4:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   501da:	4eb9 0005 54b4 	jsr 554b4 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* to prevent deletion */

  the_port = _Dual_ported_memory_Allocate();

  if ( !the_port ) {
   501e0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   501e2:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   501e4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   501e6:	6746           	beqs 5022e <rtems_port_create+0x92>               	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  the_port->internal_base = internal_start;
  the_port->external_base = external_start;
  the_port->length        = length - 1;
   501e8:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   501ec:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   501f0:	5388           	subql #1,%a0                                      	<== NOT EXECUTED
   501f2:	2348 0018      	movel %a0,%a1@(24)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   501f6:	2079 0007 140a 	moveal 7140a <_Dual_ported_memory_Information+0x1a>,%a0	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   501fc:	2340 000c      	movel %d0,%a1@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   50200:	4280           	clrl %d0                                          	<== NOT EXECUTED
   50202:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
   50206:	2189 0c00      	movel %a1,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    &_Dual_ported_memory_Information,
    &the_port->Object,
    (Objects_Name) name
  );

  *id = the_port->Object.id;
   5020a:	206e 0018      	moveal %fp@(24),%a0                               	<== NOT EXECUTED
  if ( !the_port ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_port->internal_base = internal_start;
   5020e:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
  the_port->external_base = external_start;
   50212:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
    &_Dual_ported_memory_Information,
    &the_port->Object,
    (Objects_Name) name
  );

  *id = the_port->Object.id;
   50216:	20a9 0008      	movel %a1@(8),%a0@                                	<== NOT EXECUTED
  if ( !the_port ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_port->internal_base = internal_start;
   5021a:	2340 0010      	movel %d0,%a1@(16)                                	<== NOT EXECUTED
  the_port->external_base = external_start;
   5021e:	2341 0014      	movel %d1,%a1@(20)                                	<== NOT EXECUTED
    &the_port->Object,
    (Objects_Name) name
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
   50222:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   50228:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    &the_port->Object,
    (Objects_Name) name
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
   5022a:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   5022c:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();             /* to prevent deletion */

  the_port = _Dual_ported_memory_Allocate();

  if ( !the_port ) {
    _Thread_Enable_dispatch();
   5022e:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50234:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();             /* to prevent deletion */

  the_port = _Dual_ported_memory_Allocate();

  if ( !the_port ) {
    _Thread_Enable_dispatch();
   50236:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   50238:	4e75           	rts                                               	<== NOT EXECUTED
	...

0005023c <rtems_port_delete>:
 */

rtems_status_code rtems_port_delete(
  Objects_Id id
)
{
   5023c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50240:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Dual_ported_memory_Control *)
   50242:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50246:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5024a:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   50250:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   50256:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5025c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5025e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50262:	6632           	bnes 50296 <rtems_port_delete+0x5a>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
   50264:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   50266:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   5026c:	4eb9 0005 5550 	jsr 55550 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free (
   Dual_ported_memory_Control *the_port
)
{
  _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
   50272:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   50274:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   5027a:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
      _Dual_ported_memory_Free( the_port );
      _Thread_Enable_dispatch();
   50280:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50286:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
      _Dual_ported_memory_Free( the_port );
      _Thread_Enable_dispatch();
   5028a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50290:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
      _Dual_ported_memory_Free( the_port );
      _Thread_Enable_dispatch();
   50292:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50294:	4e75           	rts                                               	<== NOT EXECUTED
   50296:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   5029a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   5029c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5029e:	4e75           	rts

000502a0 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
  Objects_Id   id,
  void        *external,
  void       **internal
)
{
   502a0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   502a4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   502a6:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !internal )
   502aa:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   502ac:	675e           	beqs 5030c <rtems_port_external_to_internal+0x6c> 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Dual_ported_memory_Control *)
   502ae:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   502b2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   502b6:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   502bc:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   502c2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   502c8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   502ca:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   502ce:	6622           	bnes 502f2 <rtems_port_external_to_internal+0x52> 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE uint32_t   _Addresses_Subtract (
  void *left,
  void *right
)
{
  return ((char *) left - (char *) right);
   502d0:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   502d4:	90a8 0014      	subl %a0@(20),%d0                                 	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( external, the_port->external_base );
      if ( ending > the_port->length )
   502d8:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   502dc:	631e           	blss 502fc <rtems_port_external_to_internal+0x5c> 	<== NOT EXECUTED
        *internal = external;
   502de:	24ae 000c      	movel %fp@(12),%a2@                               	<== NOT EXECUTED
      else
        *internal = _Addresses_Add_offset( the_port->internal_base,
                                           ending );
      _Thread_Enable_dispatch();
   502e2:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   502e8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   502ea:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   502ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   502f0:	4e75           	rts                                               	<== NOT EXECUTED
   502f2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   502f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !internal )
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   502f8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   502fa:	4e75           	rts                                               	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( external, the_port->external_base );
      if ( ending > the_port->length )
        *internal = external;
      else
        *internal = _Addresses_Add_offset( the_port->internal_base,
   502fc:	d0a8 0010      	addl %a0@(16),%d0                                 	<== NOT EXECUTED
   50300:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
                                           ending );
      _Thread_Enable_dispatch();
   50302:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   50308:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5030a:	60de           	bras 502ea <rtems_port_external_to_internal+0x4a> 	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5030c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50310:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !internal )
   50312:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50314:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050318 <rtems_port_ident>:

rtems_status_code rtems_port_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   50318:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   5031c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   50320:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   50322:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50326:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   5032c:	4eb9 0005 5bb8 	jsr 55bb8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   50332:	41f9 0006 a75e 	lea 6a75e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_ALL_NODES,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   50338:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   5033c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5033e:	4e75           	rts

00050340 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
  Objects_Id   id,
  void        *internal,
  void       **external
)
{
   50340:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50344:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   50346:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !external )
   5034a:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   5034c:	675e           	beqs 503ac <rtems_port_internal_to_external+0x6c> 	<== NOT EXECUTED
   5034e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50352:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50356:	4879 0007 13f0 	pea 713f0 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   5035c:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   50362:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50368:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   5036a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5036e:	6622           	bnes 50392 <rtems_port_internal_to_external+0x52> 	<== NOT EXECUTED
   50370:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   50374:	90a8 0010      	subl %a0@(16),%d0                                 	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( internal, the_port->internal_base );
      if ( ending > the_port->length )
   50378:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   5037c:	631e           	blss 5039c <rtems_port_internal_to_external+0x5c> 	<== NOT EXECUTED
        *external = internal;
   5037e:	24ae 000c      	movel %fp@(12),%a2@                               	<== NOT EXECUTED
      else
        *external = _Addresses_Add_offset( the_port->external_base,
                                           ending );
      _Thread_Enable_dispatch();
   50382:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   50388:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5038a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5038e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50390:	4e75           	rts                                               	<== NOT EXECUTED
   50392:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50396:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !external )
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   50398:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5039a:	4e75           	rts                                               	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( internal, the_port->internal_base );
      if ( ending > the_port->length )
        *external = internal;
      else
        *external = _Addresses_Add_offset( the_port->external_base,
   5039c:	d0a8 0014      	addl %a0@(20),%d0                                 	<== NOT EXECUTED
   503a0:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
                                           ending );
      _Thread_Enable_dispatch();
   503a2:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   503a8:	4280           	clrl %d0                                          	<== NOT EXECUTED
   503aa:	60de           	bras 5038a <rtems_port_internal_to_external+0x4a> 	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   503ac:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   503b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !external )
   503b2:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   503b4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00050f54 <rtems_rate_monotonic_cancel>:
 */

rtems_status_code rtems_rate_monotonic_cancel(
  Objects_Id id
)
{
   50f54:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   50f58:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Rate_monotonic_Control *)
   50f5a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   50f5e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   50f62:	4879 0007 1468 	pea 71468 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   50f68:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   50f6e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   50f74:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50f76:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   50f7a:	670a           	beqs 50f86 <rtems_rate_monotonic_cancel+0x32>     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f7c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50f80:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   50f82:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f84:	4e75           	rts                                               	<== NOT EXECUTED

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
   50f86:	2039 0007 16be 	movel 716be <_Thread_Executing>,%d0               	<== NOT EXECUTED
   50f8c:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   50f90:	6710           	beqs 50fa2 <rtems_rate_monotonic_cancel+0x4e>     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   50f92:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50f98:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   50f9c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
        _Thread_Enable_dispatch();
   50f9e:	7017           	moveq #23,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50fa0:	4e75           	rts                                               	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }
      (void) _Watchdog_Remove( &the_period->Timer );
   50fa2:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   50fa6:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;
   50fac:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   50fb0:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50fb6:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }
      (void) _Watchdog_Remove( &the_period->Timer );
      the_period->state = RATE_MONOTONIC_INACTIVE;
      _Thread_Enable_dispatch();
   50fba:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50fbc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }
      (void) _Watchdog_Remove( &the_period->Timer );
      the_period->state = RATE_MONOTONIC_INACTIVE;
      _Thread_Enable_dispatch();
   50fbe:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50fc0:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004688c <rtems_rate_monotonic_create>:

rtems_status_code rtems_rate_monotonic_create(
  rtems_name    name,
  Objects_Id   *id
)
{
   4688c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46890:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46892:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46894:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;

  if ( !rtems_is_name_valid( name ) )
   46898:	6700 00b6      	beqw 46950 <rtems_rate_monotonic_create+0xc4>     	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   4689c:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   468a0:	6700 00d0      	beqw 46972 <rtems_rate_monotonic_create+0xe6>     	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   468a4:	2039 0005 b6a0 	movel 5b6a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   468aa:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   468ac:	23c0 0005 b6a0 	movel %d0,5b6a0 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  This function allocates a period control block from
 *  the inactive chain of free period control blocks.
 */
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
  return (Rate_monotonic_Control *)
   468b2:	4879 0005 b598 	pea 5b598 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   468b8:	4eb9 0004 88f0 	jsr 488f0 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();            /* to prevent deletion */

  the_period = _Rate_monotonic_Allocate();

  if ( !the_period ) {
   468be:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   468c0:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   468c2:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   468c4:	6700 0098      	beqw 4695e <rtems_rate_monotonic_create+0xd2>     	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_period->owner = _Thread_Executing;
   468c8:	45f9 0005 b75e 	lea 5b75e <_Thread_Executing>,%a2                 	<== NOT EXECUTED
   468ce:	2352 0050      	movel %a2@,%a1@(80)                               	<== NOT EXECUTED
  the_period->state = RATE_MONOTONIC_INACTIVE;

  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );

  _Rate_monotonic_Reset_statistics( the_period );
   468d2:	41e9 007c      	lea %a1@(124),%a0                                 	<== NOT EXECUTED
   468d6:	42a9 0054      	clrl %a1@(84)                                     	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   468da:	4280           	clrl %d0                                          	<== NOT EXECUTED
   468dc:	42a9 0058      	clrl %a1@(88)                                     	<== NOT EXECUTED
   468e0:	42a9 0064      	clrl %a1@(100)                                    	<== NOT EXECUTED
   468e4:	42a9 0068      	clrl %a1@(104)                                    	<== NOT EXECUTED
   468e8:	42a9 006c      	clrl %a1@(108)                                    	<== NOT EXECUTED
   468ec:	42a9 0070      	clrl %a1@(112)                                    	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   468f0:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_period->owner = _Thread_Executing;
  the_period->state = RATE_MONOTONIC_INACTIVE;
   468f4:	42a9 0038      	clrl %a1@(56)                                     	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   468f8:	42a9 0018      	clrl %a1@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   468fc:	42a9 002c      	clrl %a1@(44)                                     	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   46900:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED

  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );

  _Rate_monotonic_Reset_statistics( the_period );
   46904:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   46906:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   46908:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   4690a:	4290           	clrl %a0@                                         	<== NOT EXECUTED
   4690c:	2079 0005 b5b2 	moveal 5b5b2 <_Rate_monotonic_Information+0x1a>,%a0	<== NOT EXECUTED
   46912:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
   46916:	2189 0c00      	movel %a1,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
   4691a:	203c 7fff ffff 	movel #2147483647,%d0                             	<== NOT EXECUTED
    &_Rate_monotonic_Information,
    &the_period->Object,
    (Objects_Name) name
  );

  *id = the_period->Object.id;
   46920:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   46924:	2342 000c      	movel %d2,%a1@(12)                                	<== NOT EXECUTED
  the_period->owner = _Thread_Executing;
  the_period->state = RATE_MONOTONIC_INACTIVE;

  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );

  _Rate_monotonic_Reset_statistics( the_period );
   46928:	2340 005c      	movel %d0,%a1@(92)                                	<== NOT EXECUTED
   4692c:	2340 0060      	movel %d0,%a1@(96)                                	<== NOT EXECUTED
   46930:	2340 0074      	movel %d0,%a1@(116)                               	<== NOT EXECUTED
   46934:	2340 0078      	movel %d0,%a1@(120)                               	<== NOT EXECUTED
    &_Rate_monotonic_Information,
    &the_period->Object,
    (Objects_Name) name
  );

  *id = the_period->Object.id;
   46938:	20a9 0008      	movel %a1@(8),%a0@                                	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   4693c:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46942:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46946:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4694a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    &the_period->Object,
    (Objects_Name) name
  );

  *id = the_period->Object.id;
  _Thread_Enable_dispatch();
   4694c:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4694e:	4e75           	rts                                               	<== NOT EXECUTED
   46950:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46954:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46958:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id   *id
)
{
  Rate_monotonic_Control *the_period;

  if ( !rtems_is_name_valid( name ) )
   4695a:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  );

  *id = the_period->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4695c:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();            /* to prevent deletion */

  the_period = _Rate_monotonic_Allocate();

  if ( !the_period ) {
    _Thread_Enable_dispatch();
   4695e:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  );

  *id = the_period->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46964:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46968:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4696c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();            /* to prevent deletion */

  the_period = _Rate_monotonic_Allocate();

  if ( !the_period ) {
    _Thread_Enable_dispatch();
   4696e:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
  );

  *id = the_period->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46970:	4e75           	rts                                               	<== NOT EXECUTED
   46972:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46976:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4697a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;

  if ( !rtems_is_name_valid( name ) )
    return RTEMS_INVALID_NAME;

  if ( !id )
   4697c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  );

  *id = the_period->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4697e:	4e75           	rts

000510b8 <rtems_rate_monotonic_delete>:
 */

rtems_status_code rtems_rate_monotonic_delete(
  Objects_Id id
)
{
   510b8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   510bc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Rate_monotonic_Control *)
   510be:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   510c2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   510c6:	4879 0007 1468 	pea 71468 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   510cc:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   510d2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   510d8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   510da:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   510de:	6640           	bnes 51120 <rtems_rate_monotonic_delete+0x68>     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
   510e0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   510e2:	4879 0007 1468 	pea 71468 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   510e8:	4eb9 0005 5550 	jsr 55550 <_Objects_Close>                        	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_period->Timer );
   510ee:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   510f2:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;
   510f8:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Rate_monotonic_Free (
  Rate_monotonic_Control *the_period
)
{
  _Objects_Free( &_Rate_monotonic_Information, &the_period->Object );
   510fc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   510fe:	4879 0007 1468 	pea 71468 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   51104:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
      _Rate_monotonic_Free( the_period );
      _Thread_Enable_dispatch();
   5110a:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   51110:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
      (void) _Watchdog_Remove( &the_period->Timer );
      the_period->state = RATE_MONOTONIC_INACTIVE;
      _Rate_monotonic_Free( the_period );
      _Thread_Enable_dispatch();
   51114:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5111a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
      (void) _Watchdog_Remove( &the_period->Timer );
      the_period->state = RATE_MONOTONIC_INACTIVE;
      _Rate_monotonic_Free( the_period );
      _Thread_Enable_dispatch();
   5111c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5111e:	4e75           	rts                                               	<== NOT EXECUTED
   51120:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   51124:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   51126:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   51128:	4e75           	rts                                               	<== NOT EXECUTED
	...

0006d73c <rtems_rate_monotonic_get_statistics>:

rtems_status_code rtems_rate_monotonic_get_statistics(
  Objects_Id                               id,
  rtems_rate_monotonic_period_statistics  *statistics
)
{
   6d73c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   6d740:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !statistics )
   6d742:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   6d746:	6774           	beqs 6d7bc <rtems_rate_monotonic_get_statistics+0x80>	<== NOT EXECUTED
   6d748:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   6d74c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   6d750:	4879 0009 a34c 	pea 9a34c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   6d756:	4eb9 0004 bc78 	jsr 4bc78 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6d75c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   6d762:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   6d764:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   6d768:	6648           	bnes 6d7b2 <rtems_rate_monotonic_get_statistics+0x76>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *statistics = the_period->Statistics;
   6d76a:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   6d76e:	20ea 0054      	movel %a2@(84),%a0@+                              	<== NOT EXECUTED
   6d772:	43ea 007c      	lea %a2@(124),%a1                                 	<== NOT EXECUTED
   6d776:	20ea 0058      	movel %a2@(88),%a0@+                              	<== NOT EXECUTED
   6d77a:	20ea 005c      	movel %a2@(92),%a0@+                              	<== NOT EXECUTED
   6d77e:	20ea 0060      	movel %a2@(96),%a0@+                              	<== NOT EXECUTED
   6d782:	20ea 0064      	movel %a2@(100),%a0@+                             	<== NOT EXECUTED
   6d786:	20ea 0068      	movel %a2@(104),%a0@+                             	<== NOT EXECUTED
   6d78a:	20ea 006c      	movel %a2@(108),%a0@+                             	<== NOT EXECUTED
   6d78e:	20ea 0070      	movel %a2@(112),%a0@+                             	<== NOT EXECUTED
   6d792:	20ea 0074      	movel %a2@(116),%a0@+                             	<== NOT EXECUTED
   6d796:	20ea 0078      	movel %a2@(120),%a0@+                             	<== NOT EXECUTED
   6d79a:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   6d79c:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   6d79e:	20d9           	movel %a1@+,%a0@+                                 	<== NOT EXECUTED
   6d7a0:	2091           	movel %a1@,%a0@                                   	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   6d7a2:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d7a8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   6d7ac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      *statistics = the_period->Statistics;
      _Thread_Enable_dispatch();
   6d7ae:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d7b0:	4e75           	rts                                               	<== NOT EXECUTED
   6d7b2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   6d7b6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !statistics )
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6d7b8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d7ba:	4e75           	rts                                               	<== NOT EXECUTED
   6d7bc:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   6d7c0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !statistics )
   6d7c2:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d7c4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0006d7c8 <rtems_rate_monotonic_get_status>:

rtems_status_code rtems_rate_monotonic_get_status(
  Objects_Id                           id,
  rtems_rate_monotonic_period_status  *status
)
{
   6d7c8:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   6d7cc:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   6d7d0:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !status )
   6d7d4:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   6d7d6:	676a           	beqs 6d842 <rtems_rate_monotonic_get_status+0x7a> 	<== NOT EXECUTED
   6d7d8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   6d7dc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   6d7e0:	4879 0009 a34c 	pea 9a34c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   6d7e6:	4eb9 0004 bc78 	jsr 4bc78 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6d7ec:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   6d7f2:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED
   6d7f4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   6d7f8:	663c           	bnes 6d836 <rtems_rate_monotonic_get_status+0x6e> 	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
   6d7fa:	206c 0050      	moveal %a4@(80),%a0                               	<== NOT EXECUTED
   6d7fe:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   6d800:	6700 008c      	beqw 6d88e <rtems_rate_monotonic_get_status+0xc6> 	<== NOT EXECUTED
   6d804:	2228 0008      	movel %a0@(8),%d1                                 	<== NOT EXECUTED
      status->state = the_period->state;
   6d808:	202c 0038      	movel %a4@(56),%d0                                	<== NOT EXECUTED

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
   6d80c:	2681           	movel %d1,%a3@                                    	<== NOT EXECUTED
      status->state = the_period->state;
   6d80e:	2740 0004      	movel %d0,%a3@(4)                                 	<== NOT EXECUTED

      if ( status->state == RATE_MONOTONIC_INACTIVE ) {
   6d812:	663a           	bnes 6d84e <rtems_rate_monotonic_get_status+0x86> 	<== NOT EXECUTED
        #else
          status->since_last_period = 0;
        #endif
        #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
          status->executed_since_last_period.tv_sec = 0;
          status->executed_since_last_period.tv_nsec = 0;
   6d814:	42ab 0014      	clrl %a3@(20)                                     	<== NOT EXECUTED
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
      status->state = the_period->state;

      if ( status->state == RATE_MONOTONIC_INACTIVE ) {
        #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          status->since_last_period.tv_sec = 0;
   6d818:	42ab 0008      	clrl %a3@(8)                                      	<== NOT EXECUTED
          status->since_last_period.tv_nsec = 0;
   6d81c:	42ab 000c      	clrl %a3@(12)                                     	<== NOT EXECUTED
        #else
          status->since_last_period = 0;
        #endif
        #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
          status->executed_since_last_period.tv_sec = 0;
   6d820:	42ab 0010      	clrl %a3@(16)                                     	<== NOT EXECUTED
            the_period->owner->cpu_time_used -
            the_period->owner_executed_at_period;
        #endif
      }

      _Thread_Enable_dispatch();
   6d824:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   6d82a:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d82c:	4cee 1c04 ffe4 	moveml %fp@(-28),%d2/%a2-%a4                      	<== NOT EXECUTED
   6d832:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   6d834:	4e75           	rts                                               	<== NOT EXECUTED
   6d836:	4cee 1c04 ffe4 	moveml %fp@(-28),%d2/%a2-%a4                      	<== NOT EXECUTED
   6d83c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !status )
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6d83e:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d840:	4e75           	rts                                               	<== NOT EXECUTED
   6d842:	4cee 1c04 ffe4 	moveml %fp@(-28),%d2/%a2-%a4                      	<== NOT EXECUTED
   6d848:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !status )
   6d84a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6d84c:	4e75           	rts                                               	<== 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 );
   6d84e:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   6d850:	0682 ffff fff4 	addil #-12,%d2                                    	<== NOT EXECUTED
   6d856:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6d858:	4eb9 0006 337c 	jsr 6337c <_TOD_Get_uptime>                       	<== NOT EXECUTED
        #endif

        #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          _Timespec_Subtract(
   6d85e:	486b 0008      	pea %a3@(8)                                       	<== NOT EXECUTED
   6d862:	45f9 0004 d484 	lea 4d484 <_Timespec_Subtract>,%a2                	<== NOT EXECUTED
   6d868:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6d86a:	486c 0044      	pea %a4@(68)                                      	<== NOT EXECUTED
   6d86e:	4e92           	jsr %a2@                                          	<== 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(
   6d870:	486b 0010      	pea %a3@(16)                                      	<== NOT EXECUTED
   6d874:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6d876:	4879 0009 9f46 	pea 99f46 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   6d87c:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   6d87e:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
            the_period->owner->cpu_time_used -
            the_period->owner_executed_at_period;
        #endif
      }

      _Thread_Enable_dispatch();
   6d884:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   6d88a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   6d88c:	609e           	bras 6d82c <rtems_rate_monotonic_get_status+0x64> 	<== NOT EXECUTED

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
   6d88e:	4281           	clrl %d1                                          	<== NOT EXECUTED
   6d890:	6000 ff76      	braw 6d808 <rtems_rate_monotonic_get_status+0x40> 	<== NOT EXECUTED

00046980 <rtems_rate_monotonic_ident>:

rtems_status_code rtems_rate_monotonic_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   46980:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   46984:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   46988:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   4698e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46992:	4879 0005 b598 	pea 5b598 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   46998:	4eb9 0004 90b8 	jsr 490b8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4699e:	41f9 0005 8aa4 	lea 58aa4 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   469a4:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   469a8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   469aa:	4e75           	rts

00046c06 <rtems_rate_monotonic_period>:

rtems_status_code rtems_rate_monotonic_period(
  Objects_Id        id,
  rtems_interval    length
)
{
   46c06:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   46c0a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46c0c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Rate_monotonic_Control *)
   46c0e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46c12:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46c16:	4879 0005 b598 	pea 5b598 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   46c1c:	4eb9 0004 8f20 	jsr 48f20 <_Objects_Get>                          	<== NOT EXECUTED
  rtems_rate_monotonic_period_states   local_state;
  ISR_Level                            level;

  the_period = _Rate_monotonic_Get( id, &location );

  switch ( location ) {
   46c22:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46c28:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   46c2a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46c2e:	6622           	bnes 46c52 <rtems_rate_monotonic_period+0x4c>     	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
   46c30:	2039 0005 b75e 	movel 5b75e <_Thread_Executing>,%d0               	<== NOT EXECUTED
   46c36:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   46c3a:	6726           	beqs 46c62 <rtems_rate_monotonic_period+0x5c>     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   46c3c:	7417           	moveq #23,%d2                                     	<== NOT EXECUTED
   46c3e:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46c44:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46c46:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   46c4a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46c4e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c50:	4e75           	rts                                               	<== NOT EXECUTED
          the_period->state = RATE_MONOTONIC_ACTIVE;
          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
          return RTEMS_TIMEOUT;
   46c52:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46c54:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46c56:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   46c5a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46c5e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c60:	4e75           	rts                                               	<== NOT EXECUTED
      if ( !_Thread_Is_executing( the_period->owner ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
   46c62:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   46c66:	6700 0108      	beqw 46d70 <rtems_rate_monotonic_period+0x16a>    	<== NOT EXECUTED
        }
        _Thread_Enable_dispatch();
        return( return_value );
      }

      _ISR_Disable( level );
   46c6a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46c70:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46c72:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46c74:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      switch ( the_period->state ) {
   46c76:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   46c7a:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   46c7c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46c7e:	6770           	beqs 46cf0 <rtems_rate_monotonic_period+0xea>     	<== NOT EXECUTED
   46c80:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   46c84:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46c86:	6700 00f8      	beqw 46d80 <rtems_rate_monotonic_period+0x17a>    	<== NOT EXECUTED
   46c8a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46c8c:	66c4           	bnes 46c52 <rtems_rate_monotonic_period+0x4c>     	<== NOT EXECUTED
        case RATE_MONOTONIC_INACTIVE: {

          _ISR_Enable( level );
   46c8e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

          /*
           *  Baseline statistics information for the beginning of a period.
           */
          _Rate_monotonic_Initiate_statistics( the_period );
   46c90:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46c92:	4eb9 0004 69ac 	jsr 469ac <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   46c98:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46c9c:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED

          the_period->state = RATE_MONOTONIC_ACTIVE;
   46ca0:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   46ca2:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   46ca6:	203c 0004 7084 	movel #290948,%d0                                 	<== NOT EXECUTED
  the_watchdog->id        = id;
   46cac:	2542 0030      	movel %d2,%a2@(48)                                	<== NOT EXECUTED
          );

          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   46cb0:	4282           	clrl %d2                                          	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46cb2:	2541 001c      	movel %d1,%a2@(28)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   46cb6:	2540 002c      	movel %d0,%a2@(44)                                	<== NOT EXECUTED
          _Rate_monotonic_Update_statistics( the_period );

          _ISR_Enable( level );

          the_period->state = RATE_MONOTONIC_ACTIVE;
          the_period->next_length = length;
   46cba:	2541 004c      	movel %d1,%a2@(76)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   46cbe:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   46cc2:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   46cc6:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   46cca:	4879 0005 b77c 	pea 5b77c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   46cd0:	4eb9 0004 aae4 	jsr 4aae4 <_Watchdog_Insert>                      	<== NOT EXECUTED

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   46cd6:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46cdc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46ce2:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46ce4:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   46ce8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46cec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46cee:	4e75           	rts                                               	<== NOT EXECUTED
        case RATE_MONOTONIC_ACTIVE:

          /*
           *  Update statistics from the concluding period.
           */
          _Rate_monotonic_Update_statistics( the_period );
   46cf0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46cf2:	4eb9 0004 6a2e 	jsr 46a2e <_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;
          the_period->next_length = length;
   46cf8:	222e 000c      	movel %fp@(12),%d1                                	<== 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;
   46cfc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
          the_period->next_length = length;
   46cfe:	2541 004c      	movel %d1,%a2@(76)                                	<== 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;
   46d02:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
          the_period->next_length = length;

          _ISR_Enable( level );
   46d06:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

          _Thread_Executing->Wait.id = the_period->Object.id;
   46d08:	2079 0005 b75e 	moveal 5b75e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46d0e:	216a 0008 0020 	movel %a2@(8),%a0@(32)                            	<== NOT EXECUTED
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   46d14:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>                       	<== NOT EXECUTED
   46d18:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46d1a:	4eb9 0004 a198 	jsr 4a198 <_Thread_Set_state>                     	<== NOT EXECUTED

          /*
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?
           */
          _ISR_Disable( level );
   46d20:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   46d26:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   46d28:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   46d2a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
            local_state = the_period->state;
   46d2c:	222a 0038      	movel %a2@(56),%d1                                	<== NOT EXECUTED
            the_period->state = RATE_MONOTONIC_ACTIVE;
   46d30:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
   46d32:	2542 0038      	movel %d2,%a2@(56)                                	<== NOT EXECUTED
          _ISR_Enable( level );
   46d36:	46c0           	movew %d0,%sr                                     	<== 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 )
   46d38:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   46d3a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46d40:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   46d42:	6716           	beqs 46d5a <rtems_rate_monotonic_period+0x154>    	<== NOT EXECUTED
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );

          _Thread_Enable_dispatch();
   46d44:	4282           	clrl %d2                                          	<== NOT EXECUTED
   46d46:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46d4c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46d4e:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   46d52:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46d56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46d58:	4e75           	rts                                               	<== NOT EXECUTED
          /*
           *  If it did, then we want to unblock ourself and continue as
           *  if nothing happen.  The period was reset in the timeout routine.
           */
          if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   46d5a:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>                       	<== NOT EXECUTED

          _Thread_Enable_dispatch();
   46d5e:	4282           	clrl %d2                                          	<== NOT EXECUTED
          /*
           *  If it did, then we want to unblock ourself and continue as
           *  if nothing happen.  The period was reset in the timeout routine.
           */
          if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   46d60:	2f39 0005 b75e 	movel 5b75e <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   46d66:	4eb9 0004 93cc 	jsr 493cc <_Thread_Clear_state>                   	<== NOT EXECUTED
   46d6c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46d6e:	60d6           	bras 46d46 <rtems_rate_monotonic_period+0x140>    	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
        switch ( the_period->state ) {
   46d70:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   46d74:	664a           	bnes 46dc0 <rtems_rate_monotonic_period+0x1ba>    	<== NOT EXECUTED
   46d76:	740b           	moveq #11,%d2                                     	<== NOT EXECUTED
           *  if nothing happen.  The period was reset in the timeout routine.
           */
          if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );

          _Thread_Enable_dispatch();
   46d78:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46d7e:	60cc           	bras 46d4c <rtems_rate_monotonic_period+0x146>    	<== NOT EXECUTED
        case RATE_MONOTONIC_EXPIRED:

          /*
           *  Update statistics from the concluding period
           */
          _Rate_monotonic_Update_statistics( the_period );
   46d80:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46d82:	4eb9 0004 6a2e 	jsr 46a2e <_Rate_monotonic_Update_statistics>     	<== NOT EXECUTED

          _ISR_Enable( level );
   46d88:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46d8a:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED

          the_period->state = RATE_MONOTONIC_ACTIVE;
   46d8e:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
   46d90:	2541 001c      	movel %d1,%a2@(28)                                	<== NOT EXECUTED
   46d94:	2542 0038      	movel %d2,%a2@(56)                                	<== NOT EXECUTED
          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   46d98:	143c 0006      	moveb #6,%d2                                      	<== NOT EXECUTED
          _Rate_monotonic_Update_statistics( the_period );

          _ISR_Enable( level );

          the_period->state = RATE_MONOTONIC_ACTIVE;
          the_period->next_length = length;
   46d9c:	2541 004c      	movel %d1,%a2@(76)                                	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   46da0:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   46da4:	4879 0005 b77c 	pea 5b77c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   46daa:	4eb9 0004 aae4 	jsr 4aae4 <_Watchdog_Insert>                      	<== NOT EXECUTED

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   46db0:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46db6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46dbc:	6000 ff24      	braw 46ce2 <rtems_rate_monotonic_period+0xdc>     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
        switch ( the_period->state ) {
   46dc0:	5780           	subql #3,%d0                                      	<== NOT EXECUTED
   46dc2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46dc4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46dc6:	6500 ff7c      	bcsw 46d44 <rtems_rate_monotonic_period+0x13e>    	<== NOT EXECUTED
   46dca:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
           *  if nothing happen.  The period was reset in the timeout routine.
           */
          if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );

          _Thread_Enable_dispatch();
   46dcc:	4eb9 0004 97a4 	jsr 497a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46dd2:	6000 ff78      	braw 46d4c <rtems_rate_monotonic_period+0x146>    	<== NOT EXECUTED
	...

00062906 <rtems_rate_monotonic_report_statistics>:
    }
  }
}

void rtems_rate_monotonic_report_statistics( void )
{
   62906:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
   6290a:	4879 0004 77dc 	pea 477dc <printk_plugin>                         	<== NOT EXECUTED
   62910:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   62912:	4eb9 0006 2734 	jsr 62734 <rtems_rate_monotonic_report_statistics_with_plugin>	<== NOT EXECUTED
   62918:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   6291a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   6291c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00062734 <rtems_rate_monotonic_report_statistics_with_plugin>:
 */
void rtems_rate_monotonic_report_statistics_with_plugin(
  void                  *context,
  rtems_printk_plugin_t  print
)
{
   62734:	4e56 ff78      	linkw %fp,#-136                                   	<== NOT EXECUTED
   62738:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   6273c:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   62740:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  rtems_id                               id;
  rtems_rate_monotonic_period_statistics the_stats;
  rtems_rate_monotonic_period_status     the_status;
  char                                   name[5];

  if ( !print )
   62744:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   62746:	6700 0086      	beqw 627ce <rtems_rate_monotonic_report_statistics_with_plugin+0x9a>	<== NOT EXECUTED
    return;

  (*print)( context, "Period information by period\n" );
   6274a:	4879 0008 1ea8 	pea 81ea8 <IMFS_memfile_handlers+0x1dc>           	<== NOT EXECUTED
   62750:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62752:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
  (*print)( context, "--- CPU times are in seconds ---\n" );
   62754:	4879 0008 1ec6 	pea 81ec6 <IMFS_memfile_handlers+0x1fa>           	<== NOT EXECUTED
   6275a:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   6275c:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
  (*print)( context, "--- Wall times are in seconds ---\n" );
   6275e:	4879 0008 1ee8 	pea 81ee8 <IMFS_memfile_handlers+0x21c>           	<== NOT EXECUTED
   62764:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62766:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
  Be sure to test the various cases.
  (*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
  (*print)( context, "   ID     OWNER COUNT MISSED     "
   62768:	4879 0008 1f0b 	pea 81f0b <IMFS_memfile_handlers+0x23f>           	<== NOT EXECUTED
   6276e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62770:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
       #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          "      "
       #endif
          "   WALL TIME\n"
  );
  (*print)( context, "                               "
   62772:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   62778:	2ebc 0008 1f56 	movel #532310,%sp@                                	<== NOT EXECUTED
   6277e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62780:	4e92           	jsr %a2@                                          	<== 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 ;
   62782:	2439 0009 a352 	movel 9a352 <_Rate_monotonic_Information+0x6>,%d2 	<== NOT EXECUTED
        id <= _Rate_monotonic_Information.maximum_id ;
   62788:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   6278a:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   62790:	623c           	bhis 627ce <rtems_rate_monotonic_report_statistics_with_plugin+0x9a>	<== NOT EXECUTED
   62792:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );
    if ( status != RTEMS_SUCCESSFUL )
      continue;

    /* If the above passed, so should this but check it anyway */
    status = rtems_rate_monotonic_get_status( id, &the_status );
   62794:	2e0e           	movel %fp,%d7                                     	<== NOT EXECUTED
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
      rtems_object_get_name( the_status.owner, sizeof(name), name );
   62796:	2a0e           	movel %fp,%d5                                     	<== NOT EXECUTED
   62798:	0684 ffff ffa2 	addil #-94,%d4                                    	<== NOT EXECUTED
   6279e:	47f9 0006 d73c 	lea 6d73c <rtems_rate_monotonic_get_statistics>,%a3	<== NOT EXECUTED
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );
    if ( status != RTEMS_SUCCESSFUL )
      continue;

    /* If the above passed, so should this but check it anyway */
    status = rtems_rate_monotonic_get_status( id, &the_status );
   627a4:	0687 ffff ffda 	addil #-38,%d7                                    	<== NOT EXECUTED
   627aa:	4bf9 0006 d7c8 	lea 6d7c8 <rtems_rate_monotonic_get_status>,%a5   	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   627b0:	49f9 0006 3d58 	lea 63d58 <_Timespec_Divide_by_integer>,%a4       	<== NOT EXECUTED
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
      rtems_object_get_name( the_status.owner, sizeof(name), name );
   627b6:	5b85           	subql #5,%d5                                      	<== NOT EXECUTED
   * 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++ ) {
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );
   627b8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   627ba:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   627bc:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
    if ( status != RTEMS_SUCCESSFUL )
   627be:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   627c0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   627c2:	6714           	beqs 627d8 <rtems_rate_monotonic_report_statistics_with_plugin+0xa4>	<== 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++ ) {
   627c4:	5282           	addql #1,%d2                                      	<== 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 ;
   627c6:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   627cc:	63ea           	blss 627b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x84>	<== NOT EXECUTED
        the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
      );
    #endif
    }
  }
}
   627ce:	4cee 3cfc ff78 	moveml %fp@(-136),%d2-%d7/%a2-%a5                 	<== NOT EXECUTED
   627d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   627d6:	4e75           	rts                                               	<== NOT EXECUTED
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );
    if ( status != RTEMS_SUCCESSFUL )
      continue;

    /* If the above passed, so should this but check it anyway */
    status = rtems_rate_monotonic_get_status( id, &the_status );
   627d8:	2f07           	movel %d7,%sp@-                                   	<== NOT EXECUTED
   627da:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   627dc:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
        continue;
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
   627de:	202e ffda      	movel %fp@(-38),%d0                               	<== NOT EXECUTED
    #if defined(RTEMS_DEBUG)
      if ( status != RTEMS_SUCCESSFUL )
        continue;
    #endif

    name[ 0 ] = '\0';
   627e2:	4201           	clrb %d1                                          	<== NOT EXECUTED

    if ( the_status.owner ) {
   627e4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    #if defined(RTEMS_DEBUG)
      if ( status != RTEMS_SUCCESSFUL )
        continue;
    #endif

    name[ 0 ] = '\0';
   627e6:	1d41 fffb      	moveb %d1,%fp@(-5)                                	<== NOT EXECUTED

    if ( the_status.owner ) {
   627ea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   627ec:	663a           	bnes 62828 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>	<== NOT EXECUTED

    /*
     *  Print part of report line that is not dependent on granularity
     */

    (*print)( context,
   627ee:	2f2e ffa6      	movel %fp@(-90),%sp@-                             	<== NOT EXECUTED
   627f2:	2f2e ffa2      	movel %fp@(-94),%sp@-                             	<== NOT EXECUTED
   627f6:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   627f8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   627fa:	4879 0008 1fa2 	pea 81fa2 <IMFS_memfile_handlers+0x2d6>           	<== NOT EXECUTED
   62800:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62802:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

    /*
     *  If the count is zero, don't print statistics
     */

    if (the_stats.count == 0) {
   62804:	202e ffa2      	movel %fp@(-94),%d0                               	<== NOT EXECUTED
   62808:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   6280e:	664e           	bnes 6285e <rtems_rate_monotonic_report_statistics_with_plugin+0x12a>	<== NOT EXECUTED
      (*print)( context, "\n" );
   62810:	4879 0008 2289 	pea 82289 <__func__.5623+0x118>                   	<== 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++ ) {
   62816:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
    /*
     *  If the count is zero, don't print statistics
     */

    if (the_stats.count == 0) {
      (*print)( context, "\n" );
   62818:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   6281a:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   6281c:	508f           	addql #8,%sp                                      	<== 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 ;
   6281e:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   62824:	6392           	blss 627b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x84>	<== NOT EXECUTED
   62826:	60a6           	bras 627ce <rtems_rate_monotonic_report_statistics_with_plugin+0x9a>	<== NOT EXECUTED
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
      rtems_object_get_name( the_status.owner, sizeof(name), name );
   62828:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   6282a:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   6282e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   62830:	4eb9 0004 a008 	jsr 4a008 <rtems_object_get_name>                 	<== NOT EXECUTED
   62836:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

    /*
     *  Print part of report line that is not dependent on granularity
     */

    (*print)( context,
   6283c:	2f2e ffa6      	movel %fp@(-90),%sp@-                             	<== NOT EXECUTED
   62840:	2f2e ffa2      	movel %fp@(-94),%sp@-                             	<== NOT EXECUTED
   62844:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   62846:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   62848:	4879 0008 1fa2 	pea 81fa2 <IMFS_memfile_handlers+0x2d6>           	<== NOT EXECUTED
   6284e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   62850:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

    /*
     *  If the count is zero, don't print statistics
     */

    if (the_stats.count == 0) {
   62852:	202e ffa2      	movel %fp@(-94),%d0                               	<== NOT EXECUTED
   62856:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   6285c:	67b2           	beqs 62810 <rtems_rate_monotonic_report_statistics_with_plugin+0xdc>	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   6285e:	486e fff2      	pea %fp@(-14)                                     	<== NOT EXECUTED
         &the_stats.total_cpu_time,
         the_stats.count,
         &cpu_average
      );
      (*print)( context,
   62862:	2c3c 0000 03e8 	movel #1000,%d6                                   	<== 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++ ) {
   62868:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   6286a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   6286c:	486e ffba      	pea %fp@(-70)                                     	<== NOT EXECUTED
   62870:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
         &the_stats.total_cpu_time,
         the_stats.count,
         &cpu_average
      );
      (*print)( context,
   62872:	202e fff6      	movel %fp@(-10),%d0                               	<== NOT EXECUTED
   62876:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   6287a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   6287c:	202e ffb6      	movel %fp@(-74),%d0                               	<== NOT EXECUTED
   62880:	2f2e fff2      	movel %fp@(-14),%sp@-                             	<== NOT EXECUTED
   62884:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   62888:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   6288a:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   6288c:	202e ffae      	movel %fp@(-82),%d0                               	<== NOT EXECUTED
   62890:	2f2e ffb2      	movel %fp@(-78),%sp@-                             	<== NOT EXECUTED
   62894:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   62898:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   6289a:	2f2e ffaa      	movel %fp@(-86),%sp@-                             	<== NOT EXECUTED
   6289e:	4879 0008 1fb9 	pea 81fb9 <IMFS_memfile_handlers+0x2ed>           	<== NOT EXECUTED
   628a4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   628a6:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
     *  print Wall time part of statistics
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
      struct timespec  wall_average;
      _Timespec_Divide_by_integer(
   628a8:	dffc 0000 002c 	addal #44,%sp                                     	<== NOT EXECUTED
   628ae:	486e fff2      	pea %fp@(-14)                                     	<== NOT EXECUTED
   628b2:	2f2e ffa2      	movel %fp@(-94),%sp@-                             	<== NOT EXECUTED
   628b6:	486e ffd2      	pea %fp@(-46)                                     	<== NOT EXECUTED
   628ba:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
         &the_stats.total_wall_time,
         the_stats.count,
         &wall_average
      );
      (*print)( context,
   628bc:	202e fff6      	movel %fp@(-10),%d0                               	<== NOT EXECUTED
   628c0:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   628c4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   628c6:	222e ffce      	movel %fp@(-50),%d1                               	<== NOT EXECUTED
   628ca:	2f2e fff2      	movel %fp@(-14),%sp@-                             	<== NOT EXECUTED
   628ce:	4c46 1801      	remsl %d6,%d1,%d1                                 	<== NOT EXECUTED
   628d2:	2241           	moveal %d1,%a1                                    	<== NOT EXECUTED
   628d4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   628d6:	202e ffc6      	movel %fp@(-58),%d0                               	<== NOT EXECUTED
   628da:	2f2e ffca      	movel %fp@(-54),%sp@-                             	<== NOT EXECUTED
   628de:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   628e2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   628e4:	2f2e ffc2      	movel %fp@(-62),%sp@-                             	<== NOT EXECUTED
   628e8:	4879 0008 1fd8 	pea 81fd8 <IMFS_memfile_handlers+0x30c>           	<== NOT EXECUTED
   628ee:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   628f0:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   628f2:	dffc 0000 002c 	addal #44,%sp                                     	<== 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 ;
   628f8:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   628fe:	6300 feb8      	blsw 627b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x84>	<== NOT EXECUTED
   62902:	6000 feca      	braw 627ce <rtems_rate_monotonic_report_statistics_with_plugin+0x9a>	<== NOT EXECUTED

00062920 <rtems_rate_monotonic_reset_all_statistics>:

/*
 *  rtems_rate_monotonic_reset_all_statistics
 */
void rtems_rate_monotonic_reset_all_statistics( void )
{
   62920:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   62924:	2039 0009 9e80 	movel 99e80 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   6292a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   6292c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   6292e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   62930:	23c0 0009 9e80 	movel %d0,99e80 <_Thread_Dispatch_disable_level>  	<== 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 ;
   62936:	2439 0009 a352 	movel 9a352 <_Rate_monotonic_Information+0x6>,%d2 	<== NOT EXECUTED
          id <= _Rate_monotonic_Information.maximum_id ;
   6293c:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   62942:	6216           	bhis 6295a <rtems_rate_monotonic_reset_all_statistics+0x3a>	<== NOT EXECUTED
   62944:	45f9 0006 296c 	lea 6296c <rtems_rate_monotonic_reset_statistics>,%a2	<== NOT EXECUTED
          id++ ) {
      status = rtems_rate_monotonic_reset_statistics( id );
   6294a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6294c:	4e92           	jsr %a2@                                          	<== 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++ ) {
   6294e:	5282           	addql #1,%d2                                      	<== 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 ;
   62950:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   62952:	b4b9 0009 a356 	cmpl 9a356 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   62958:	63f0           	blss 6294a <rtems_rate_monotonic_reset_all_statistics+0x2a>	<== NOT EXECUTED

  /*
   *  Done so exit thread dispatching disabled critical section.
   */
  _Thread_Enable_dispatch();
}
   6295a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   6295e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   62962:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    }

  /*
   *  Done so exit thread dispatching disabled critical section.
   */
  _Thread_Enable_dispatch();
   62964:	4ef9 0004 c554 	jmp 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
	...

0006296c <rtems_rate_monotonic_reset_statistics>:
 */

rtems_status_code rtems_rate_monotonic_reset_statistics(
  Objects_Id                               id
)
{
   6296c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Rate_monotonic_Control *)
   62970:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   62974:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   62978:	4879 0009 a34c 	pea 9a34c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   6297e:	4eb9 0004 bc78 	jsr 4bc78 <_Objects_Get>                          	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   62984:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   6298a:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   6298c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   62990:	6646           	bnes 629d8 <rtems_rate_monotonic_reset_statistics+0x6c>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Rate_monotonic_Reset_statistics( the_period );
   62992:	42a9 0054      	clrl %a1@(84)                                     	<== NOT EXECUTED
   62996:	41e9 007c      	lea %a1@(124),%a0                                 	<== NOT EXECUTED
   6299a:	42a9 0058      	clrl %a1@(88)                                     	<== NOT EXECUTED
   6299e:	42a9 0064      	clrl %a1@(100)                                    	<== NOT EXECUTED
   629a2:	203c 7fff ffff 	movel #2147483647,%d0                             	<== NOT EXECUTED
   629a8:	42a9 0068      	clrl %a1@(104)                                    	<== NOT EXECUTED
   629ac:	42a9 006c      	clrl %a1@(108)                                    	<== NOT EXECUTED
   629b0:	42a9 0070      	clrl %a1@(112)                                    	<== NOT EXECUTED
   629b4:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   629b6:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   629b8:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
   629ba:	4290           	clrl %a0@                                         	<== NOT EXECUTED
   629bc:	2340 0078      	movel %d0,%a1@(120)                               	<== NOT EXECUTED
   629c0:	2340 005c      	movel %d0,%a1@(92)                                	<== NOT EXECUTED
   629c4:	2340 0060      	movel %d0,%a1@(96)                                	<== NOT EXECUTED
   629c8:	2340 0074      	movel %d0,%a1@(116)                               	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   629cc:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   629d2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      _Rate_monotonic_Reset_statistics( the_period );
      _Thread_Enable_dispatch();
   629d4:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   629d6:	4e75           	rts                                               	<== NOT EXECUTED
   629d8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   629da:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   629dc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00051738 <rtems_region_create>:
  uint32_t            length,
  uint32_t            page_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   51738:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5173c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5173e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   51740:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  rtems_status_code  return_status;
  Region_Control    *the_region;

  if ( !rtems_is_name_valid( name ) )
   51744:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   51748:	6720           	beqs 5176a <rtems_region_create+0x32>             	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !starting_address )
   5174a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   5174c:	670c           	beqs 5175a <rtems_region_create+0x22>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !id )
   5174e:	4aae 001c      	tstl %fp@(28)                                     	<== NOT EXECUTED
   51752:	6706           	beqs 5175a <rtems_region_create+0x22>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_Addresses_Is_aligned( starting_address ) )
   51754:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   51756:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   51758:	6720           	beqs 5177a <rtems_region_create+0x42>             	<== NOT EXECUTED
        return_status = RTEMS_SUCCESSFUL;
      }
    }

  _RTEMS_Unlock_allocator();
  return return_status;
   5175a:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   5175c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   5175e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51762:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   51766:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51768:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  rtems_status_code  return_status;
  Region_Control    *the_region;

  if ( !rtems_is_name_valid( name ) )
   5176a:	7403           	moveq #3,%d2                                      	<== NOT EXECUTED
      }
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   5176c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   5176e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51772:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   51776:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51778:	4e75           	rts                                               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_Addresses_Is_aligned( starting_address ) )
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */
   5177a:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51780:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
 *  This function allocates a region control block from
 *  the inactive chain of free region control blocks.
 */
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
  return (Region_Control *) _Objects_Allocate( &_Region_Information );
   51786:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   5178c:	4eb9 0005 54b4 	jsr 554b4 <_Objects_Allocate>                     	<== NOT EXECUTED

    the_region = _Region_Allocate();

    if ( !the_region )
   51792:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   51794:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   51796:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   51798:	6700 00ca      	beqw 51864 <rtems_region_create+0x12c>            	<== NOT EXECUTED
      return_status = RTEMS_TOO_MANY;

    else {

      the_region->maximum_segment_size = _Heap_Initialize(
   5179c:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   517a0:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   517a4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   517a6:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   517aa:	4eb9 0005 4fbc 	jsr 54fbc <_Heap_Initialize>                      	<== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size
      );

      if ( !the_region->maximum_segment_size ) {
   517b0:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    if ( !the_region )
      return_status = RTEMS_TOO_MANY;

    else {

      the_region->maximum_segment_size = _Heap_Initialize(
   517b6:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size
      );

      if ( !the_region->maximum_segment_size ) {
   517ba:	662e           	bnes 517ea <rtems_region_create+0xb2>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Region_Free (
  Region_Control *the_region
)
{
  _Objects_Free( &_Region_Information, &the_region->Object );
   517bc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   517be:	7408           	moveq #8,%d2                                      	<== NOT EXECUTED
   517c0:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   517c6:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
   517cc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
        *id = the_region->Object.id;
        return_status = RTEMS_SUCCESSFUL;
      }
    }

  _RTEMS_Unlock_allocator();
   517ce:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   517d4:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   517da:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   517dc:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   517de:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   517e2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   517e6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   517e8:	4e75           	rts                                               	<== NOT EXECUTED
      }

      else {

        the_region->starting_address      = starting_address;
        the_region->length                = length;
   517ea:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   517ee:	2540 0054      	movel %d0,%a2@(84)                                	<== NOT EXECUTED
        the_region->page_size             = page_size;
   517f2:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
        the_region->attribute_set         = attribute_set;
   517f6:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED

      else {

        the_region->starting_address      = starting_address;
        the_region->length                = length;
        the_region->page_size             = page_size;
   517fa:	2548 0058      	movel %a0,%a2@(88)                                	<== NOT EXECUTED
        the_region->attribute_set         = attribute_set;
   517fe:	2540 0060      	movel %d0,%a2@(96)                                	<== NOT EXECUTED
        the_region->number_of_used_blocks = 0;

        _Thread_queue_Initialize(
   51802:	e488           	lsrl #2,%d0                                       	<== NOT EXECUTED
   51804:	2d40 0018      	movel %d0,%fp@(24)                                	<== NOT EXECUTED
   51808:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        return_status = RTEMS_INVALID_SIZE;
      }

      else {

        the_region->starting_address      = starting_address;
   5180a:	2542 0050      	movel %d2,%a2@(80)                                	<== NOT EXECUTED
          &_Region_Information,
          &the_region->Object,
          (Objects_Name) name
        );

        *id = the_region->Object.id;
   5180e:	4282           	clrl %d2                                          	<== NOT EXECUTED

        the_region->starting_address      = starting_address;
        the_region->length                = length;
        the_region->page_size             = page_size;
        the_region->attribute_set         = attribute_set;
        the_region->number_of_used_blocks = 0;
   51810:	42aa 0064      	clrl %a2@(100)                                    	<== NOT EXECUTED

        _Thread_queue_Initialize(
   51814:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   51818:	4878 0040      	pea 40 <FP_REGS_SAVED>                            	<== NOT EXECUTED
   5181c:	c0ae 0018      	andl %fp@(24),%d0                                 	<== NOT EXECUTED
   51820:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   51822:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   51826:	4eb9 0005 6ac4 	jsr 56ac4 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   5182c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   51830:	2548 000c      	movel %a0,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   51834:	2079 0007 14be 	moveal 714be <_Region_Information+0x1a>,%a0       	<== NOT EXECUTED
   5183a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5183c:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   51840:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
          &_Region_Information,
          &the_region->Object,
          (Objects_Name) name
        );

        *id = the_region->Object.id;
   51844:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
   51848:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   5184c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
        return_status = RTEMS_SUCCESSFUL;
      }
    }

  _RTEMS_Unlock_allocator();
   51852:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51858:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   5185e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51860:	6000 ff7a      	braw 517dc <rtems_region_create+0xa4>             	<== NOT EXECUTED
   51864:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

  _RTEMS_Lock_allocator();                      /* to prevent deletion */

    the_region = _Region_Allocate();

    if ( !the_region )
   5186a:	7405           	moveq #5,%d2                                      	<== NOT EXECUTED
        *id = the_region->Object.id;
        return_status = RTEMS_SUCCESSFUL;
      }
    }

  _RTEMS_Unlock_allocator();
   5186c:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51872:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51874:	6000 ff66      	braw 517dc <rtems_region_create+0xa4>             	<== NOT EXECUTED

00051878 <rtems_region_delete>:
 */

rtems_status_code rtems_region_delete(
  Objects_Id id
)
{
   51878:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5187c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5187e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();
   51880:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51886:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   5188c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51890:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51894:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   5189a:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   518a0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   518a2:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   518a6:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   518ac:	6622           	bnes 518d0 <rtems_region_delete+0x58>             	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        _Region_Debug_Walk( the_region, 5 );
        if ( the_region->number_of_used_blocks != 0 )
   518ae:	4aaa 0064      	tstl %a2@(100)                                    	<== NOT EXECUTED
   518b2:	675a           	beqs 5190e <rtems_region_delete+0x96>             	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518b4:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        _Region_Debug_Walk( the_region, 5 );
        if ( the_region->number_of_used_blocks != 0 )
   518ba:	740c           	moveq #12,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518bc:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   518c2:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   518c4:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   518c8:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   518cc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   518ce:	4e75           	rts                                               	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   518d0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   518d2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   518d4:	671c           	beqs 518f2 <rtems_region_delete+0x7a>             	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518d6:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   518dc:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518de:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   518e4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   518e6:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   518ea:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   518ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   518f0:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518f2:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   518f8:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   518fa:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   51900:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51902:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51906:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5190a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5190c:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_LOCAL:
        _Region_Debug_Walk( the_region, 5 );
        if ( the_region->number_of_used_blocks != 0 )
          return_status = RTEMS_RESOURCE_IN_USE;
        else {
          _Objects_Close( &_Region_Information, &the_region->Object );
   5190e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Region_Free (
  Region_Control *the_region
)
{
  _Objects_Free( &_Region_Information, &the_region->Object );
   51910:	4282           	clrl %d2                                          	<== NOT EXECUTED
   51912:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51918:	4eb9 0005 5550 	jsr 55550 <_Objects_Close>                        	<== NOT EXECUTED
   5191e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51920:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51926:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
   5192c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51932:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51938:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   5193e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51940:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51944:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   51948:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5194a:	4e75           	rts

0005194c <rtems_region_extend>:
rtems_status_code rtems_region_extend(
  Objects_Id          id,
  void               *starting_address,
  uint32_t            length
)
{
   5194c:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   51950:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51952:	2f02           	movel %d2,%sp@-                                   	<== 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 )
   51954:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   51958:	6700 00a8      	beqw 51a02 <rtems_region_extend+0xb6>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */
   5195c:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51962:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   51968:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   5196c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51970:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51976:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   5197c:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   5197e:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   51982:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51988:	664e           	bnes 519d8 <rtems_region_extend+0x8c>             	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        heap_status = _Heap_Extend(
   5198a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5198e:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   51992:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51996:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   5199a:	4eb9 0005 4cb8 	jsr 54cb8 <_Heap_Extend>                          	<== NOT EXECUTED
          starting_address,
          length,
          &amount_extended
        );

        switch ( heap_status ) {
   519a0:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   519a6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   519a8:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   519aa:	6766           	beqs 51a12 <rtems_region_extend+0xc6>             	<== NOT EXECUTED
   519ac:	6376           	blss 51a24 <rtems_region_extend+0xd8>             	<== NOT EXECUTED
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
   519ae:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
            the_region->maximum_segment_size  += amount_extended;
   519b2:	d1aa 005c      	addl %d0,%a2@(92)                                 	<== NOT EXECUTED
          &amount_extended
        );

        switch ( heap_status ) {
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
   519b6:	d1aa 0054      	addl %d0,%a2@(84)                                 	<== NOT EXECUTED
            the_region->maximum_segment_size  += amount_extended;
   519ba:	4282           	clrl %d2                                          	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   519bc:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   519c2:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   519c8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   519ca:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   519cc:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   519d0:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   519d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   519d6:	4e75           	rts                                               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   519d8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   519da:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   519dc:	6712           	beqs 519f0 <rtems_region_extend+0xa4>             	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   519de:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
        switch ( heap_status ) {
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
            the_region->maximum_segment_size  += amount_extended;
            return_status = RTEMS_SUCCESSFUL;
            break;
   519e4:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   519e6:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   519ec:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   519ee:	60da           	bras 519ca <rtems_region_extend+0x7e>             	<== NOT EXECUTED
   519f0:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   519f6:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   519f8:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   519fe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51a00:	60c8           	bras 519ca <rtems_region_extend+0x7e>             	<== 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 )
   51a02:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51a04:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51a06:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   51a0a:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   51a0e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51a10:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a12:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
          starting_address,
          length,
          &amount_extended
        );

        switch ( heap_status ) {
   51a18:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a1a:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51a20:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51a22:	60a6           	bras 519ca <rtems_region_extend+0x7e>             	<== NOT EXECUTED
          starting_address,
          length,
          &amount_extended
        );

        switch ( heap_status ) {
   51a24:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   51a28:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51a2a:	66b2           	bnes 519de <rtems_region_extend+0x92>             	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a2c:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
        switch ( heap_status ) {
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
            the_region->maximum_segment_size  += amount_extended;
            return_status = RTEMS_SUCCESSFUL;
            break;
   51a32:	7418           	moveq #24,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a34:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51a3a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51a3c:	608c           	bras 519ca <rtems_region_extend+0x7e>             	<== NOT EXECUTED
	...

00051a40 <rtems_region_get_free_information>:

rtems_status_code rtems_region_get_free_information(
  Objects_Id              id,
  Heap_Information_block *the_info
)
{
   51a40:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   51a44:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51a46:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   51a4a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !the_info )
   51a4c:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   51a4e:	677e           	beqs 51ace <rtems_region_get_free_information+0x8e>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   51a50:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51a56:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
   51a5c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51a60:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51a64:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51a6a:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51a70:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51a72:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   51a76:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51a7c:	6724           	beqs 51aa2 <rtems_region_get_free_information+0x62>	<== NOT EXECUTED
   51a7e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51a80:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51a82:	675a           	beqs 51ade <rtems_region_get_free_information+0x9e>	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a84:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51a8a:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51a8c:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51a92:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51a94:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51a96:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51a9a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   51a9e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51aa0:	4e75           	rts                                               	<== NOT EXECUTED

        the_info->Used.number   = 0;
        the_info->Used.total    = 0;
        the_info->Used.largest  = 0;

        _Heap_Get_free_information( &the_region->Memory, &the_info->Free );
   51aa2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51aa4:	4282           	clrl %d2                                          	<== NOT EXECUTED
   51aa6:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:

        the_info->Used.number   = 0;
   51aaa:	42aa 000c      	clrl %a2@(12)                                     	<== NOT EXECUTED
        the_info->Used.total    = 0;
   51aae:	42aa 0014      	clrl %a2@(20)                                     	<== NOT EXECUTED
        the_info->Used.largest  = 0;
   51ab2:	42aa 0010      	clrl %a2@(16)                                     	<== NOT EXECUTED

        _Heap_Get_free_information( &the_region->Memory, &the_info->Free );
   51ab6:	4eb9 0005 4ef4 	jsr 54ef4 <_Heap_Get_free_information>            	<== NOT EXECUTED
   51abc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51abe:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51ac4:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51aca:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51acc:	60c6           	bras 51a94 <rtems_region_get_free_information+0x54>	<== NOT EXECUTED
{
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !the_info )
   51ace:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51ad0:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51ad2:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51ad6:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   51ada:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51adc:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51ade:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51ae4:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51ae6:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51aec:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51aee:	60a4           	bras 51a94 <rtems_region_get_free_information+0x54>	<== NOT EXECUTED

00051af0 <rtems_region_get_information>:

rtems_status_code rtems_region_get_information(
  Objects_Id              id,
  Heap_Information_block *the_info
)
{
   51af0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   51af4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !the_info )
   51af6:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   51afa:	6774           	beqs 51b70 <rtems_region_get_information+0x80>    	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   51afc:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51b02:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
   51b08:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51b0c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51b10:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51b16:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51b1c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51b1e:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   51b22:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51b28:	6720           	beqs 51b4a <rtems_region_get_information+0x5a>    	<== NOT EXECUTED
   51b2a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51b2c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51b2e:	674c           	beqs 51b7c <rtems_region_get_information+0x8c>    	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b30:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51b36:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b38:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51b3e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51b40:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51b42:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51b46:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51b48:	4e75           	rts                                               	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( _Heap_Get_information( &the_region->Memory, the_info ) !=
   51b4a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51b4e:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
   51b52:	4eb9 0005 4f38 	jsr 54f38 <_Heap_Get_information>                 	<== NOT EXECUTED
   51b58:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   51b5a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   51b5c:	6730           	beqs 51b8e <rtems_region_get_information+0x9e>    	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b5e:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( _Heap_Get_information( &the_region->Memory, the_info ) !=
   51b64:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b66:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51b6c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51b6e:	60d0           	bras 51b40 <rtems_region_get_information+0x50>    	<== NOT EXECUTED
{
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !the_info )
   51b70:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51b72:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51b74:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51b78:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51b7a:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b7c:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51b82:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b84:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51b8a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51b8c:	60b2           	bras 51b40 <rtems_region_get_information+0x50>    	<== NOT EXECUTED
   51b8e:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( _Heap_Get_information( &the_region->Memory, the_info ) !=
   51b94:	4282           	clrl %d2                                          	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51b96:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51b9c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51b9e:	60a0           	bras 51b40 <rtems_region_get_information+0x50>    	<== NOT EXECUTED

00051ba0 <rtems_region_get_segment>:
  uint32_t           size,
  rtems_option       option_set,
  rtems_interval     timeout,
  void              **segment
)
{
   51ba0:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   51ba4:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   51ba8:	246e 0018      	moveal %fp@(24),%a2                               	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;
  void                    *the_segment;

  if ( !segment )
   51bac:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   51bae:	6700 009c      	beqw 51c4c <rtems_region_get_segment+0xac>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  *segment = NULL;
   51bb2:	4292           	clrl %a2@                                         	<== NOT EXECUTED

  if ( size == 0 )
   51bb4:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   51bb8:	660e           	bnes 51bc8 <rtems_region_get_segment+0x28>        	<== NOT EXECUTED
   51bba:	7408           	moveq #8,%d2                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51bbc:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51bbe:	4cee 1c04 ffec 	moveml %fp@(-20),%d2/%a2-%a4                      	<== NOT EXECUTED
   51bc4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51bc6:	4e75           	rts                                               	<== NOT EXECUTED
  *segment = NULL;

  if ( size == 0 )
    return RTEMS_INVALID_SIZE;

  _RTEMS_Lock_allocator();
   51bc8:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51bce:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
   51bd4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED

    executing  = _Thread_Executing;
   51bd8:	2879 0007 16be 	moveal 716be <_Thread_Executing>,%a4              	<== NOT EXECUTED
   51bde:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51be2:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51be8:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51bee:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51bf0:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   51bf4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51bfa:	6626           	bnes 51c22 <rtems_region_get_segment+0x82>        	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        if ( size > the_region->maximum_segment_size )
   51bfc:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   51c00:	b0ab 005c      	cmpl %a3@(92),%d0                                 	<== NOT EXECUTED
   51c04:	6354           	blss 51c5a <rtems_region_get_segment+0xba>        	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c06:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    executing  = _Thread_Executing;
    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( size > the_region->maximum_segment_size )
   51c0c:	7408           	moveq #8,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c0e:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51c14:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51c16:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51c18:	4cee 1c04 ffec 	moveml %fp@(-20),%d2/%a2-%a4                      	<== NOT EXECUTED
   51c1e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51c20:	4e75           	rts                                               	<== NOT EXECUTED

  _RTEMS_Lock_allocator();

    executing  = _Thread_Executing;
    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51c22:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51c24:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51c26:	6712           	beqs 51c3a <rtems_region_get_segment+0x9a>        	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c28:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

  _RTEMS_Lock_allocator();

    executing  = _Thread_Executing;
    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51c2e:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c30:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51c36:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51c38:	60dc           	bras 51c16 <rtems_region_get_segment+0x76>        	<== NOT EXECUTED
   51c3a:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );

            _Thread_Enable_dispatch();

            return (rtems_status_code) executing->Wait.return_code;
   51c40:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c42:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51c48:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51c4a:	60ca           	bras 51c16 <rtems_region_get_segment+0x76>        	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;
  void                    *the_segment;

  if ( !segment )
   51c4c:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51c4e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51c50:	4cee 1c04 ffec 	moveml %fp@(-20),%d2/%a2-%a4                      	<== NOT EXECUTED
   51c56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51c58:	4e75           	rts                                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
  Region_Control *the_region,
  uint32_t        size
)
{
   return _Heap_Allocate( &the_region->Memory, size );
   51c5a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51c5e:	486b 0068      	pea %a3@(104)                                     	<== NOT EXECUTED
   51c62:	4eb9 0005 4bf4 	jsr 54bf4 <_Heap_Allocate>                        	<== NOT EXECUTED

          the_segment = _Region_Allocate_segment( the_region, size );

          _Region_Debug_Walk( the_region, 2 );

          if ( the_segment ) {
   51c68:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   51c6a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   51c6c:	6718           	beqs 51c86 <rtems_region_get_segment+0xe6>        	<== NOT EXECUTED
            the_region->number_of_used_blocks += 1;
   51c6e:	52ab 0064      	addql #1,%a3@(100)                                	<== NOT EXECUTED
            *segment = the_segment;
   51c72:	4282           	clrl %d2                                          	<== NOT EXECUTED
   51c74:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c76:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51c7c:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51c82:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51c84:	6090           	bras 51c16 <rtems_region_get_segment+0x76>        	<== NOT EXECUTED
            the_region->number_of_used_blocks += 1;
            *segment = the_segment;
            return_status = RTEMS_SUCCESSFUL;
          }

          else if ( _Options_Is_no_wait( option_set ) ) {
   51c86:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   51c8a:	0801 0000      	btst #0,%d1                                       	<== NOT EXECUTED
   51c8e:	6714           	beqs 51ca4 <rtems_region_get_segment+0x104>       	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c90:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
            the_region->number_of_used_blocks += 1;
            *segment = the_segment;
            return_status = RTEMS_SUCCESSFUL;
          }

          else if ( _Options_Is_no_wait( option_set ) ) {
   51c96:	740d           	moveq #13,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51c98:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51c9e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51ca0:	6000 ff74      	braw 51c16 <rtems_region_get_segment+0x76>        	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   51ca4:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   51caa:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   51cac:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== 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();
   51cb2:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51cb8:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

            executing->Wait.queue           = &the_region->Wait_queue;
            executing->Wait.id              = id;
   51cbe:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   51cc2:	2941 0020      	movel %d1,%a4@(32)                                	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   51cc6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
             *  because this thread is going to block.
             */
            _Thread_Disable_dispatch();
            _RTEMS_Unlock_allocator();

            executing->Wait.queue           = &the_region->Wait_queue;
   51cc8:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   51cca:	2741 0040      	movel %d1,%a3@(64)                                	<== NOT EXECUTED
            executing->Wait.id              = id;
            executing->Wait.count           = size;
   51cce:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
             *  because this thread is going to block.
             */
            _Thread_Disable_dispatch();
            _RTEMS_Unlock_allocator();

            executing->Wait.queue           = &the_region->Wait_queue;
   51cd2:	0680 0000 0010 	addil #16,%d0                                     	<== NOT EXECUTED
   51cd8:	2940 0044      	movel %d0,%a4@(68)                                	<== NOT EXECUTED
            executing->Wait.id              = id;
            executing->Wait.count           = size;
   51cdc:	2941 0024      	movel %d1,%a4@(36)                                	<== NOT EXECUTED
            executing->Wait.return_argument = segment;
   51ce0:	294a 0028      	movel %a2,%a4@(40)                                	<== NOT EXECUTED

            _Thread_queue_Enter_critical_section( &the_region->Wait_queue );

            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
   51ce4:	4879 0005 6bc8 	pea 56bc8 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   51cea:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   51cee:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   51cf0:	4eb9 0005 6808 	jsr 56808 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

            _Thread_Enable_dispatch();
   51cf6:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

            return (rtems_status_code) executing->Wait.return_code;
   51cfc:	242c 0034      	movel %a4@(52),%d2                                	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51d00:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED

            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );

            _Thread_Enable_dispatch();

            return (rtems_status_code) executing->Wait.return_code;
   51d02:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51d08:	4cee 1c04 ffec 	moveml %fp@(-20),%d2/%a2-%a4                      	<== NOT EXECUTED
   51d0e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51d10:	4e75           	rts                                               	<== NOT EXECUTED
	...

00051d14 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
  Objects_Id         id,
  void              *segment,
  size_t            *size
)
{
   51d14:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   51d18:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !segment )
   51d1a:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   51d1e:	6700 0084      	beqw 51da4 <rtems_region_get_segment_size+0x90>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !size )
   51d22:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   51d26:	677c           	beqs 51da4 <rtems_region_get_segment_size+0x90>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   51d28:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51d2e:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   51d34:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51d38:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51d3c:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51d42:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51d48:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51d4a:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   51d4e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51d54:	6720           	beqs 51d76 <rtems_region_get_segment_size+0x62>   	<== NOT EXECUTED
   51d56:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51d58:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51d5a:	6754           	beqs 51db0 <rtems_region_get_segment_size+0x9c>   	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51d5c:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51d62:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51d64:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51d6a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51d6c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51d6e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51d72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51d74:	4e75           	rts                                               	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) )
   51d76:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   51d7a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51d7e:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
   51d82:	4eb9 0005 5378 	jsr 55378 <_Heap_Size_of_user_area>               	<== NOT EXECUTED
   51d88:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   51d8e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   51d90:	6630           	bnes 51dc2 <rtems_region_get_segment_size+0xae>   	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51d92:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) )
   51d98:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51d9a:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51da0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51da2:	60c8           	bras 51d6c <rtems_region_get_segment_size+0x58>   	<== NOT EXECUTED
  return return_status;
   51da4:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   51da6:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51da8:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   51dac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51dae:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51db0:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51db6:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51db8:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51dbe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51dc0:	60aa           	bras 51d6c <rtems_region_get_segment_size+0x58>   	<== NOT EXECUTED
   51dc2:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:
        if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) )
   51dc8:	4282           	clrl %d2                                          	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51dca:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51dd0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51dd2:	6098           	bras 51d6c <rtems_region_get_segment_size+0x58>   	<== NOT EXECUTED

00051dd4 <rtems_region_ident>:

rtems_status_code rtems_region_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   51dd4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   51dd8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51ddc:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   51de2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51de6:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51dec:	4eb9 0005 5bb8 	jsr 55bb8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   51df2:	41f9 0006 a75e 	lea 6a75e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   51df8:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   51dfc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51dfe:	4e75           	rts

00051e00 <rtems_region_resize_segment>:
  Objects_Id  id,
  void       *segment,
  size_t      size,
  size_t     *old_size
)
{
   51e00:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   51e04:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51e06:	2f02           	movel %d2,%sp@-                                   	<== 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 )
   51e08:	4aae 0014      	tstl %fp@(20)                                     	<== NOT EXECUTED
   51e0c:	6700 00ba      	beqw 51ec8 <rtems_region_resize_segment+0xc8>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   51e10:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51e16:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
   51e1c:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   51e20:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51e24:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51e2a:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51e30:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51e32:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   51e36:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51e3c:	6726           	beqs 51e64 <rtems_region_resize_segment+0x64>     	<== NOT EXECUTED
   51e3e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51e40:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51e42:	6700 0094      	beqw 51ed8 <rtems_region_resize_segment+0xd8>     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51e46:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51e4c:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51e4e:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51e54:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51e56:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51e58:	242e ffec      	movel %fp@(-20),%d2                               	<== NOT EXECUTED
   51e5c:	246e fff0      	moveal %fp@(-16),%a2                              	<== NOT EXECUTED
   51e60:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51e62:	4e75           	rts                                               	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        _Region_Debug_Walk( the_region, 7 );

        status = _Heap_Resize_block(
   51e64:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51e68:	486e fff4      	pea %fp@(-12)                                     	<== NOT EXECUTED
   51e6c:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   51e70:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51e74:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   51e78:	4eb9 0005 51b4 	jsr 551b4 <_Heap_Resize_block>                    	<== NOT EXECUTED
          segment,
          (uint32_t) size,
          &osize,
          &avail_size
        );
        *old_size = (uint32_t) osize;
   51e7e:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   51e82:	20ae fff4      	movel %fp@(-12),%a0@                              	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        _Region_Debug_Walk( the_region, 7 );

        status = _Heap_Resize_block(
   51e86:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
        );
        *old_size = (uint32_t) osize;

        _Region_Debug_Walk( the_region, 8 );

        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
   51e88:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   51e8e:	6624           	bnes 51eb4 <rtems_region_resize_segment+0xb4>     	<== NOT EXECUTED
   51e90:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   51e94:	6656           	bnes 51eec <rtems_region_resize_segment+0xec>     	<== NOT EXECUTED
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else
          _RTEMS_Unlock_allocator();
   51e96:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51e9c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   51e9e:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51ea4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51ea6:	242e ffec      	movel %fp@(-20),%d2                               	<== NOT EXECUTED
   51eaa:	246e fff0      	moveal %fp@(-16),%a2                              	<== NOT EXECUTED
        _Region_Debug_Walk( the_region, 8 );

        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else
          _RTEMS_Unlock_allocator();
   51eae:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51eb0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51eb2:	4e75           	rts                                               	<== NOT EXECUTED
        _Region_Debug_Walk( the_region, 8 );

        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else
          _RTEMS_Unlock_allocator();
   51eb4:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51eba:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

        return
   51ec0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51ec2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   51ec4:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   51ec6:	673c           	beqs 51f04 <rtems_region_resize_segment+0x104>    	<== NOT EXECUTED
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
   51ec8:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   51eca:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51ecc:	242e ffec      	movel %fp@(-20),%d2                               	<== NOT EXECUTED
   51ed0:	246e fff0      	moveal %fp@(-16),%a2                              	<== NOT EXECUTED
   51ed4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51ed6:	4e75           	rts                                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51ed8:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else
          _RTEMS_Unlock_allocator();

        return
   51ede:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51ee0:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51ee6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51ee8:	6000 ff6c      	braw 51e56 <rtems_region_resize_segment+0x56>     	<== NOT EXECUTED
        *old_size = (uint32_t) osize;

        _Region_Debug_Walk( the_region, 8 );

        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
   51eec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51eee:	4eb9 0005 97a4 	jsr 597a4 <_Region_Process_queue>                 	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51ef4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51ef6:	242e ffec      	movel %fp@(-20),%d2                               	<== NOT EXECUTED
   51efa:	246e fff0      	moveal %fp@(-16),%a2                              	<== NOT EXECUTED
        *old_size = (uint32_t) osize;

        _Region_Debug_Walk( the_region, 8 );

        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
   51efe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51f00:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51f02:	4e75           	rts                                               	<== NOT EXECUTED
        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else
          _RTEMS_Unlock_allocator();

        return
   51f04:	740d           	moveq #13,%d2                                     	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51f06:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51f08:	242e ffec      	movel %fp@(-20),%d2                               	<== NOT EXECUTED
   51f0c:	246e fff0      	moveal %fp@(-16),%a2                              	<== NOT EXECUTED
   51f10:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51f12:	4e75           	rts

00051f14 <rtems_region_return_segment>:

rtems_status_code rtems_region_return_segment(
  Objects_Id  id,
  void       *segment
)
{
   51f14:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   51f18:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51f1a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t                 size;
#endif
  int                      status;
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();
   51f1c:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   51f22:	4eb9 0005 3f9c 	jsr 53f9c <_API_Mutex_Lock>                       	<== NOT EXECUTED
   51f28:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   51f2c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   51f30:	4879 0007 14a4 	pea 714a4 <_Region_Information>                   	<== NOT EXECUTED
   51f36:	4eb9 0005 59e0 	jsr 559e0 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   51f3c:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51f3e:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   51f42:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   51f48:	6632           	bnes 51f7c <rtems_region_return_segment+0x68>     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
  Region_Control *the_region,
  void           *the_segment
)
{
  return _Heap_Free( &the_region->Memory, the_segment );
   51f4a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   51f4e:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   51f52:	4eb9 0005 4d70 	jsr 54d70 <_Heap_Free>                            	<== NOT EXECUTED
#endif
          status = _Region_Free_segment( the_region, segment );

          _Region_Debug_Walk( the_region, 4 );

          if ( !status )
   51f58:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   51f5a:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   51f5c:	6648           	bnes 51fa6 <rtems_region_return_segment+0x92>     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51f5e:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
          else {
            the_region->number_of_used_blocks -= 1;

            _Region_Process_queue(the_region); /* unlocks allocator */

            return RTEMS_SUCCESSFUL;
   51f64:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51f66:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51f6c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   51f6e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51f70:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51f74:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   51f78:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51f7a:	4e75           	rts                                               	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51f7c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51f7e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   51f80:	6712           	beqs 51f94 <rtems_region_return_segment+0x80>     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51f82:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51f88:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51f8a:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51f90:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51f92:	60da           	bras 51f6e <rtems_region_return_segment+0x5a>     	<== NOT EXECUTED
   51f94:	2f39 0007 16b6 	movel 716b6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   51f9a:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   51f9c:	4eb9 0005 4000 	jsr 54000 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   51fa2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   51fa4:	60c8           	bras 51f6e <rtems_region_return_segment+0x5a>     	<== NOT EXECUTED

          if ( !status )
            return_status = RTEMS_INVALID_ADDRESS;

          else {
            the_region->number_of_used_blocks -= 1;
   51fa6:	53aa 0064      	subql #1,%a2@(100)                                	<== NOT EXECUTED

            _Region_Process_queue(the_region); /* unlocks allocator */
   51faa:	4282           	clrl %d2                                          	<== NOT EXECUTED
   51fac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   51fae:	4eb9 0005 97a4 	jsr 597a4 <_Region_Process_queue>                 	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51fb4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   51fb6:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   51fba:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
            return_status = RTEMS_INVALID_ADDRESS;

          else {
            the_region->number_of_used_blocks -= 1;

            _Region_Process_queue(the_region); /* unlocks allocator */
   51fbe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        break;
    }

  _RTEMS_Unlock_allocator();
  return return_status;
}
   51fc0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51fc2:	4e75           	rts

00045920 <rtems_semaphore_create>:
  uint32_t             count,
  rtems_attribute      attribute_set,
  rtems_task_priority  priority_ceiling,
  rtems_id            *id
)
{
   45920:	4e56 ffdc      	linkw %fp,#-36                                    	<== NOT EXECUTED
   45924:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   45928:	242e 0010      	movel %fp@(16),%d2                                	<== 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 ) )
   4592c:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   45930:	675c           	beqs 4598e <rtems_semaphore_create+0x6e>          	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   45932:	4aae 0018      	tstl %fp@(24)                                     	<== NOT EXECUTED
   45936:	6762           	beqs 4599a <rtems_semaphore_create+0x7a>          	<== NOT EXECUTED
  uint32_t             count,
  rtems_attribute      attribute_set,
  rtems_task_priority  priority_ceiling,
  rtems_id            *id
)
{
   45938:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4593a:	0280 0000 00c0 	andil #192,%d0                                    	<== NOT EXECUTED
      return RTEMS_NOT_DEFINED;

  } else
#endif

  if ( _Attributes_Is_inherit_priority( attribute_set ) ||
   45940:	671e           	beqs 45960 <rtems_semaphore_create+0x40>          	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
  rtems_attribute attribute_set
)
{
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
   45942:	7630           	moveq #48,%d3                                     	<== NOT EXECUTED
   45944:	c682           	andl %d2,%d3                                      	<== NOT EXECUTED
              _Attributes_Is_priority_ceiling( attribute_set ) ) {

    if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
   45946:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   45948:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   4594a:	6732           	beqs 4597e <rtems_semaphore_create+0x5e>          	<== NOT EXECUTED
   4594c:	123c 0020      	moveb #32,%d1                                     	<== NOT EXECUTED
   45950:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   45952:	672a           	beqs 4597e <rtems_semaphore_create+0x5e>          	<== NOT EXECUTED
      name,
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   45954:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
}
   45956:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   4595c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4595e:	4e75           	rts                                               	<== NOT EXECUTED
      return RTEMS_NOT_DEFINED;

  } else
#endif

  if ( _Attributes_Is_inherit_priority( attribute_set ) ||
   45960:	7630           	moveq #48,%d3                                     	<== NOT EXECUTED
   45962:	c682           	andl %d2,%d3                                      	<== NOT EXECUTED

  if ( _Attributes_Is_inherit_priority( attribute_set ) &&
       _Attributes_Is_priority_ceiling( attribute_set ) )
    return RTEMS_NOT_DEFINED;

  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
   45964:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   45966:	673e           	beqs 459a6 <rtems_semaphore_create+0x86>          	<== NOT EXECUTED
   45968:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4596a:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   4596e:	6436           	bccs 459a6 <rtems_semaphore_create+0x86>          	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45970:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   45976:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( _Attributes_Is_inherit_priority( attribute_set ) &&
       _Attributes_Is_priority_ceiling( attribute_set ) )
    return RTEMS_NOT_DEFINED;

  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
   45978:	103c 000a      	moveb #10,%d0                                     	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   4597c:	4e75           	rts                                               	<== NOT EXECUTED
#endif

  if ( _Attributes_Is_inherit_priority( attribute_set ) ||
              _Attributes_Is_priority_ceiling( attribute_set ) ) {

    if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
   4597e:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   45980:	66d2           	bnes 45954 <rtems_semaphore_create+0x34>          	<== NOT EXECUTED
             _Attributes_Is_priority( attribute_set ) ) )
      return RTEMS_NOT_DEFINED;

  }

  if ( _Attributes_Is_inherit_priority( attribute_set ) &&
   45982:	0c80 0000 00c0 	cmpil #192,%d0                                    	<== NOT EXECUTED
   45988:	66da           	bnes 45964 <rtems_semaphore_create+0x44>          	<== NOT EXECUTED
      name,
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   4598a:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   4598c:	60c8           	bras 45956 <rtems_semaphore_create+0x36>          	<== NOT EXECUTED
}
   4598e:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   45994:	4e5e           	unlk %fp                                          	<== 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 ) )
   45996:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45998:	4e75           	rts                                               	<== NOT EXECUTED
   4599a:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   459a0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  CORE_semaphore_Attributes   the_semaphore_attributes;

  if ( !rtems_is_name_valid( name ) )
    return RTEMS_INVALID_NAME;

  if ( !id )
   459a2:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   459a4:	4e75           	rts                                               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   459a6:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   459ac:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   459ae:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  This function allocates a semaphore control block from
 *  the inactive chain of free semaphore control blocks.
 */
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
  return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
   459b4:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   459ba:	4eb9 0004 6f0c 	jsr 46f0c <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* prevents deletion */

  the_semaphore = _Semaphore_Allocate();

  if ( !the_semaphore ) {
   459c0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   459c2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   459c4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   459c6:	6700 00ee      	beqw 45ab6 <rtems_semaphore_create+0x196>         	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_semaphore->attribute_set = attribute_set;
   459ca:	2542 0010      	movel %d2,%a2@(16)                                	<== 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 ) ) {
   459ce:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   459d0:	6772           	beqs 45a44 <rtems_semaphore_create+0x124>         	<== NOT EXECUTED
    CORE_mutex_Status mutex_status;

    if ( _Attributes_Is_inherit_priority( attribute_set ) )
   459d2:	0802 0006      	btst #6,%d2                                       	<== NOT EXECUTED
   459d6:	6700 00d0      	beqw 45aa8 <rtems_semaphore_create+0x188>         	<== NOT EXECUTED
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
   459da:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   459dc:	2d41 fff0      	movel %d1,%fp@(-16)                               	<== NOT EXECUTED
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
    else
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;


    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
   459e0:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   459e2:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   459e4:	6700 00e2      	beqw 45ac8 <rtems_semaphore_create+0x1a8>         	<== NOT EXECUTED
          the_mutex_attributes.only_owner_release = TRUE;
          break;
      }
    } else {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
      the_mutex_attributes.only_owner_release = FALSE;
   459e8:	4201           	clrb %d1                                          	<== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
          the_mutex_attributes.only_owner_release = TRUE;
          break;
      }
    } else {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
   459ea:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
      the_mutex_attributes.only_owner_release = FALSE;
   459ec:	1d41 ffee      	moveb %d1,%fp@(-18)                               	<== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
          the_mutex_attributes.only_owner_release = TRUE;
          break;
      }
    } else {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
   459f0:	2d40 ffea      	movel %d0,%fp@(-22)                               	<== NOT EXECUTED
      the_mutex_attributes.only_owner_release = FALSE;
    }

    the_mutex_attributes.priority_ceiling = priority_ceiling;

    mutex_status = _CORE_mutex_Initialize(
   459f4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   459f6:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   459fa:	57c0           	seq %d0                                           	<== NOT EXECUTED
   459fc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   459fe:	4480           	negl %d0                                          	<== NOT EXECUTED
   45a00:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45a02:	486e ffea      	pea %fp@(-22)                                     	<== NOT EXECUTED
   45a06:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
    } else {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
      the_mutex_attributes.only_owner_release = FALSE;
    }

    the_mutex_attributes.priority_ceiling = priority_ceiling;
   45a0a:	2d6e 0014 fff4 	movel %fp@(20),%fp@(-12)                          	<== NOT EXECUTED

    mutex_status = _CORE_mutex_Initialize(
   45a10:	4eb9 0004 671c 	jsr 4671c <_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 ) {
   45a16:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45a1c:	7206           	moveq #6,%d1                                      	<== NOT EXECUTED
   45a1e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45a20:	6654           	bnes 45a76 <rtems_semaphore_create+0x156>         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
  Semaphore_Control *the_semaphore
)
{
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
   45a22:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45a24:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45a2a:	4eb9 0004 72cc 	jsr 472cc <_Objects_Free>                         	<== NOT EXECUTED
       _Semaphore_Free( the_semaphore );
       _Thread_Enable_dispatch();
   45a30:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45a36:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45a38:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   45a3e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
     );

     if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
       _Semaphore_Free( the_semaphore );
       _Thread_Enable_dispatch();
   45a40:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45a42:	4e75           	rts                                               	<== NOT EXECUTED
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;

    _CORE_semaphore_Initialize(
   45a44:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
       _Thread_Enable_dispatch();
       return RTEMS_INVALID_PRIORITY;
     }
  } else {
    if ( _Attributes_Is_priority( attribute_set ) )
      the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
   45a48:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   45a4a:	56c0           	sne %d0                                           	<== NOT EXECUTED
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;

    _CORE_semaphore_Initialize(
   45a4c:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
       _Thread_Enable_dispatch();
       return RTEMS_INVALID_PRIORITY;
     }
  } else {
    if ( _Attributes_Is_priority( attribute_set ) )
      the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
   45a50:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   45a52:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45a54:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED

    /*
     *  This effectively disables limit checking.
     */

    the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
   45a58:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
   45a5a:	2d40 fff8      	movel %d0,%fp@(-8)                                	<== NOT EXECUTED
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;

    _CORE_semaphore_Initialize(
   45a5e:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED

    /*
     *  The following are just to make Purify happy.
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
   45a62:	42ae ffea      	clrl %fp@(-22)                                    	<== NOT EXECUTED
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
   45a66:	42ae fff4      	clrl %fp@(-12)                                    	<== NOT EXECUTED

    _CORE_semaphore_Initialize(
   45a6a:	4eb9 0004 6a90 	jsr 46a90 <_CORE_semaphore_Initialize>            	<== NOT EXECUTED
   45a70:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   45a76:	2079 0005 86a2 	moveal 586a2 <_Semaphore_Information+0x1a>,%a0    	<== NOT EXECUTED
   45a7c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45a7e:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   45a82:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   45a86:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    &_Semaphore_Information,
    &the_semaphore->Object,
    (Objects_Name) name
  );

  *id = the_semaphore->Object.id;
   45a8a:	206e 0018      	moveal %fp@(24),%a0                               	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   45a8e:	2541 000c      	movel %d1,%a2@(12)                                	<== NOT EXECUTED
   45a92:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
      the_semaphore->Object.id,
      name,
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
   45a96:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45a9c:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   45aa2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      the_semaphore->Object.id,
      name,
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
   45aa4:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45aa6:	4e75           	rts                                               	<== NOT EXECUTED
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    CORE_mutex_Status mutex_status;

    if ( _Attributes_Is_inherit_priority( attribute_set ) )
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
    else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
   45aa8:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   45aaa:	6c36           	bges 45ae2 <rtems_semaphore_create+0x1c2>         	<== NOT EXECUTED
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
   45aac:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45aae:	2d40 fff0      	movel %d0,%fp@(-16)                               	<== NOT EXECUTED
   45ab2:	6000 ff2c      	braw 459e0 <rtems_semaphore_create+0xc0>          	<== NOT EXECUTED
  _Thread_Disable_dispatch();             /* prevents deletion */

  the_semaphore = _Semaphore_Allocate();

  if ( !the_semaphore ) {
    _Thread_Enable_dispatch();
   45ab6:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45abc:	4cee 040c ffdc 	moveml %fp@(-36),%d2-%d3/%a2                      	<== NOT EXECUTED
   45ac2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();             /* prevents deletion */

  the_semaphore = _Semaphore_Allocate();

  if ( !the_semaphore ) {
    _Thread_Enable_dispatch();
   45ac4:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   45ac6:	4e75           	rts                                               	<== NOT EXECUTED


    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;

      switch ( the_mutex_attributes.discipline ) {
   45ac8:	202e fff0      	movel %fp@(-16),%d0                               	<== NOT EXECUTED
    else
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;


    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
   45acc:	42ae ffea      	clrl %fp@(-22)                                    	<== NOT EXECUTED

      switch ( the_mutex_attributes.discipline ) {
   45ad0:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   45ad4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45ad6:	651a           	bcss 45af2 <rtems_semaphore_create+0x1d2>         	<== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_FIFO:
        case CORE_MUTEX_DISCIPLINES_PRIORITY:
          the_mutex_attributes.only_owner_release = FALSE;
   45ad8:	4200           	clrb %d0                                          	<== NOT EXECUTED
   45ada:	1d40 ffee      	moveb %d0,%fp@(-18)                               	<== NOT EXECUTED
   45ade:	6000 ff14      	braw 459f4 <rtems_semaphore_create+0xd4>          	<== NOT EXECUTED
    if ( _Attributes_Is_inherit_priority( attribute_set ) )
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
    else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
    else if ( _Attributes_Is_priority( attribute_set ) )
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
   45ae2:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   45ae4:	56c0           	sne %d0                                           	<== NOT EXECUTED
   45ae6:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   45ae8:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45aea:	2d40 fff0      	movel %d0,%fp@(-16)                               	<== NOT EXECUTED
   45aee:	6000 fef0      	braw 459e0 <rtems_semaphore_create+0xc0>          	<== NOT EXECUTED


    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;

      switch ( the_mutex_attributes.discipline ) {
   45af2:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   45af6:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45af8:	6500 fefa      	bcsw 459f4 <rtems_semaphore_create+0xd4>          	<== 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;
   45afc:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45afe:	1d41 ffee      	moveb %d1,%fp@(-18)                               	<== NOT EXECUTED
   45b02:	6000 fef0      	braw 459f4 <rtems_semaphore_create+0xd4>          	<== NOT EXECUTED
	...

00045b08 <rtems_semaphore_delete>:
#endif

rtems_status_code rtems_semaphore_delete(
  rtems_id   id
)
{
   45b08:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45b0c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Semaphore_Control *)
   45b0e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45b12:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45b16:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45b1c:	4eb9 0004 7438 	jsr 47438 <_Objects_Get>                          	<== NOT EXECUTED
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   45b22:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45b28:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45b2a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45b2e:	670a           	beqs 45b3a <rtems_semaphore_delete+0x32>          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45b30:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   45b34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   45b36:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45b38:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
  rtems_attribute attribute_set
)
{
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
   45b3a:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   45b3c:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   45b40:	6764           	beqs 45ba6 <rtems_semaphore_delete+0x9e>          	<== NOT EXECUTED
        if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
   45b42:	4aaa 0062      	tstl %a2@(98)                                     	<== NOT EXECUTED
   45b46:	6616           	bnes 45b5e <rtems_semaphore_delete+0x56>          	<== NOT EXECUTED
   45b48:	7220           	moveq #32,%d1                                     	<== NOT EXECUTED
   45b4a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45b4c:	6710           	beqs 45b5e <rtems_semaphore_delete+0x56>          	<== NOT EXECUTED
             !_Attributes_Is_simple_binary_semaphore(
                 the_semaphore->attribute_set ) ) {
          _Thread_Enable_dispatch();
   45b4e:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45b54:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   45b58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
        if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
             !_Attributes_Is_simple_binary_semaphore(
                 the_semaphore->attribute_set ) ) {
          _Thread_Enable_dispatch();
   45b5a:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45b5c:	4e75           	rts                                               	<== NOT EXECUTED
             !_Attributes_Is_simple_binary_semaphore(
                 the_semaphore->attribute_set ) ) {
          _Thread_Enable_dispatch();
          return RTEMS_RESOURCE_IN_USE;
        }
        _CORE_mutex_Flush(
   45b5e:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   45b62:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45b64:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   45b68:	4eb9 0004 6710 	jsr 46710 <_CORE_mutex_Flush>                     	<== NOT EXECUTED
   45b6e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
          SEMAPHORE_MP_OBJECT_WAS_DELETED,
          CORE_SEMAPHORE_WAS_DELETED
        );
     }

      _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
   45b74:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45b76:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45b7c:	4eb9 0004 6fa8 	jsr 46fa8 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
  Semaphore_Control *the_semaphore
)
{
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
   45b82:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45b84:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45b8a:	4eb9 0004 72cc 	jsr 472cc <_Objects_Free>                         	<== NOT EXECUTED
          0,                         /* Not used */
          0                          /* Not used */
        );
      }
#endif
      _Thread_Enable_dispatch();
   45b90:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45b96:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45b9c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45b9e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   45ba2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45ba4:	4e75           	rts                                               	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          SEMAPHORE_MP_OBJECT_WAS_DELETED,
          CORE_MUTEX_WAS_DELETED
        );
      } else {
        _CORE_semaphore_Flush(
   45ba6:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   45baa:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45bac:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   45bb0:	4eb9 0004 6a84 	jsr 46a84 <_CORE_semaphore_Flush>                 	<== NOT EXECUTED
   45bb6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
          SEMAPHORE_MP_OBJECT_WAS_DELETED,
          CORE_SEMAPHORE_WAS_DELETED
        );
     }

      _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
   45bbc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45bbe:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45bc4:	4eb9 0004 6fa8 	jsr 46fa8 <_Objects_Close>                        	<== NOT EXECUTED
   45bca:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45bcc:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45bd2:	4eb9 0004 72cc 	jsr 472cc <_Objects_Free>                         	<== NOT EXECUTED
          0,                         /* Not used */
          0                          /* Not used */
        );
      }
#endif
      _Thread_Enable_dispatch();
   45bd8:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45bde:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45be4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45be6:	60b6           	bras 45b9e <rtems_semaphore_delete+0x96>          	<== NOT EXECUTED

00062a4c <rtems_semaphore_flush>:
#endif

rtems_status_code rtems_semaphore_flush(
  rtems_id        id
)
{
   62a4c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   62a50:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   62a54:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   62a58:	4879 0009 9db4 	pea 99db4 <_Semaphore_Information>                	<== NOT EXECUTED
   62a5e:	4eb9 0004 bc78 	jsr 4bc78 <_Objects_Get>                          	<== NOT EXECUTED
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   62a64:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   62a6a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   62a6c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   62a70:	6706           	beqs 62a78 <rtems_semaphore_flush+0x2c>           	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   62a72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   62a74:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   62a76:	4e75           	rts                                               	<== NOT EXECUTED

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   62a78:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   62a7a:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   62a7e:	6722           	beqs 62aa2 <rtems_semaphore_flush+0x56>           	<== NOT EXECUTED
        _CORE_mutex_Flush(
   62a80:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   62a84:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   62a86:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   62a8a:	4eb9 0004 adec 	jsr 4adec <_CORE_mutex_Flush>                     	<== NOT EXECUTED
   62a90:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,
          SEND_OBJECT_WAS_DELETED,
          CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
        );
      }
      _Thread_Enable_dispatch();
   62a96:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   62a9c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   62a9e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   62aa0:	4e75           	rts                                               	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          SEND_OBJECT_WAS_DELETED,
          CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
        );
      } else {
        _CORE_semaphore_Flush(
   62aa2:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   62aa6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   62aa8:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   62aac:	4eb9 0004 b160 	jsr 4b160 <_CORE_semaphore_Flush>                 	<== NOT EXECUTED
   62ab2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,
          SEND_OBJECT_WAS_DELETED,
          CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
        );
      }
      _Thread_Enable_dispatch();
   62ab8:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   62abe:	4280           	clrl %d0                                          	<== NOT EXECUTED
   62ac0:	60dc           	bras 62a9e <rtems_semaphore_flush+0x52>           	<== NOT EXECUTED
	...

00052304 <rtems_semaphore_ident>:
rtems_status_code rtems_semaphore_ident(
  rtems_name  name,
  uint32_t    node,
  rtems_id   *id
)
{
   52304:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32( &_Semaphore_Information, name, node, id );
   52308:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   5230c:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52310:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52314:	4879 0007 14e0 	pea 714e0 <_Semaphore_Information>                	<== NOT EXECUTED
   5231a:	4eb9 0005 5bb8 	jsr 55bb8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   52320:	41f9 0006 a75e 	lea 6a75e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
}
   52326:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   5232a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5232c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045be8 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
  rtems_id        id,
  rtems_option    option_set,
  rtems_interval  timeout
)
{
   45be8:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
  Objects_Id         id,
  Objects_Locations *location,
  ISR_Level         *level
)
{
  return (Semaphore_Control *)
   45bec:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   45bf0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45bf4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45bf8:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45bfe:	4eb9 0004 73dc 	jsr 473dc <_Objects_Get_isr_disable>              	<== NOT EXECUTED
  register Semaphore_Control     *the_semaphore;
  Objects_Locations               location;
  ISR_Level                       level;

  the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
  switch ( location ) {
   45c04:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45c0a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   45c0c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45c10:	6706           	beqs 45c18 <rtems_semaphore_obtain+0x30>          	<== NOT EXECUTED
      break;

  }

  return RTEMS_INVALID_ID;
}
   45c12:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  register Semaphore_Control     *the_semaphore;
  Objects_Locations               location;
  ISR_Level                       level;

  the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
  switch ( location ) {
   45c14:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
      break;

  }

  return RTEMS_INVALID_ID;
}
   45c16:	4e75           	rts                                               	<== NOT EXECUTED

  the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   45c18:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   45c1a:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   45c1e:	673c           	beqs 45c5c <rtems_semaphore_obtain+0x74>          	<== NOT EXECUTED
        _CORE_mutex_Seize(
   45c20:	2f2e fff8      	movel %fp@(-8),%sp@-                              	<== NOT EXECUTED
   45c24:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45c26:	b1ae 000c      	eorl %d0,%fp@(12)                                 	<== NOT EXECUTED
   45c2a:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   45c2e:	c0ae 000c      	andl %fp@(12),%d0                                 	<== NOT EXECUTED
   45c32:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45c34:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45c38:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   45c3c:	4eb9 0004 68a6 	jsr 468a6 <_CORE_mutex_Seize>                     	<== NOT EXECUTED
          id,
          ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
          timeout,
          level
        );
        return _Semaphore_Translate_core_mutex_return_code(
   45c42:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45c48:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   45c4c:	4eb9 0004 5da4 	jsr 45da4 <_Semaphore_Translate_core_mutex_return_code>	<== NOT EXECUTED
   45c52:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
      break;

  }

  return RTEMS_INVALID_ID;
}
   45c58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45c5a:	4e75           	rts                                               	<== NOT EXECUTED
  Watchdog_Interval        timeout,
  ISR_Level               *level_p
)
{
  Thread_Control *executing;
  ISR_Level       level = *level_p;
   45c5c:	222e fff8      	movel %fp@(-8),%d1                                	<== NOT EXECUTED

  /* disabled when you get here */

  executing = _Thread_Executing;
   45c60:	2279 0005 8812 	moveal 58812 <_Thread_Executing>,%a1              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
   45c66:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED
  if ( the_semaphore->count != 0 ) {
   45c6a:	2028 005c      	movel %a0@(92),%d0                                	<== NOT EXECUTED
   45c6e:	6628           	bnes 45c98 <rtems_semaphore_obtain+0xb0>          	<== NOT EXECUTED
    the_semaphore->count -= 1;
    _ISR_Enable( level );
    return;
  }

  if ( !wait ) {
   45c70:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   45c74:	0800 0000      	btst #0,%d0                                       	<== NOT EXECUTED
   45c78:	673a           	beqs 45cb4 <rtems_semaphore_obtain+0xcc>          	<== NOT EXECUTED
    _ISR_Enable( level );
   45c7a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
   45c7c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        id,
        ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
        timeout,
        &level
      );
      return _Semaphore_Translate_core_semaphore_return_code(
   45c7e:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45c84:	2340 0034      	movel %d0,%a1@(52)                                	<== NOT EXECUTED
   45c88:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   45c8c:	4eb9 0004 5dba 	jsr 45dba <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
   45c92:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      break;

  }

  return RTEMS_INVALID_ID;
}
   45c94:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45c96:	4e75           	rts                                               	<== NOT EXECUTED
  /* disabled when you get here */

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
  if ( the_semaphore->count != 0 ) {
    the_semaphore->count -= 1;
   45c98:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   45c9a:	2140 005c      	movel %d0,%a0@(92)                                	<== NOT EXECUTED
    _ISR_Enable( level );
   45c9e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
        id,
        ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
        timeout,
        &level
      );
      return _Semaphore_Translate_core_semaphore_return_code(
   45ca0:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45ca6:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   45caa:	4eb9 0004 5dba 	jsr 45dba <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
   45cb0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45cb2:	60e0           	bras 45c94 <rtems_semaphore_obtain+0xac>          	<== NOT EXECUTED
   45cb4:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45cba:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45cbc:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   45cc2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45cc4:	2140 0044      	movel %d0,%a0@(68)                                	<== NOT EXECUTED
    return;
  }

  _Thread_Disable_dispatch();
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
  executing->Wait.queue          = &the_semaphore->Wait_queue;
   45cc8:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
  executing->Wait.id             = id;
   45cca:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
    return;
  }

  _Thread_Disable_dispatch();
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
  executing->Wait.queue          = &the_semaphore->Wait_queue;
   45cce:	0680 0000 0014 	addil #20,%d0                                     	<== NOT EXECUTED
  executing->Wait.id             = id;
   45cd4:	2348 0020      	movel %a0,%a1@(32)                                	<== NOT EXECUTED
    return;
  }

  _Thread_Disable_dispatch();
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
  executing->Wait.queue          = &the_semaphore->Wait_queue;
   45cd8:	2340 0044      	movel %d0,%a1@(68)                                	<== NOT EXECUTED
  executing->Wait.id             = id;
  _ISR_Enable( level );
   45cdc:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
   45cde:	4879 0004 85e0 	pea 485e0 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   45ce4:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   45ce8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45cea:	4eb9 0004 8220 	jsr 48220 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   45cf0:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45cf6:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45cfc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45d02:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   45d06:	4eb9 0004 5dba 	jsr 45dba <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
   45d0c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45d0e:	6084           	bras 45c94 <rtems_semaphore_obtain+0xac>          	<== NOT EXECUTED

00045d10 <rtems_semaphore_release>:
#endif

rtems_status_code rtems_semaphore_release(
  rtems_id   id
)
{
   45d10:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45d14:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Semaphore_Control *)
   45d16:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45d1a:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   45d1e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d20:	4879 0005 8688 	pea 58688 <_Semaphore_Information>                	<== NOT EXECUTED
   45d26:	4eb9 0004 7438 	jsr 47438 <_Objects_Get>                          	<== NOT EXECUTED
  Objects_Locations           location;
  CORE_mutex_Status           mutex_status;
  CORE_semaphore_Status       semaphore_status;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   45d2c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45d32:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   45d34:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45d38:	670a           	beqs 45d44 <rtems_semaphore_release+0x34>         	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d3a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   45d3e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Locations           location;
  CORE_mutex_Status           mutex_status;
  CORE_semaphore_Status       semaphore_status;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   45d40:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d42:	4e75           	rts                                               	<== NOT EXECUTED

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   45d44:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   45d46:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   45d4a:	662c           	bnes 45d78 <rtems_semaphore_release+0x68>         	<== NOT EXECUTED
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
      } else {
        semaphore_status = _CORE_semaphore_Surrender(
   45d4c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45d4e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d50:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   45d54:	4eb9 0004 6ad8 	jsr 46ad8 <_CORE_semaphore_Surrender>             	<== NOT EXECUTED
   45d5a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
   45d5c:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
        return
   45d62:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d64:	4eb9 0004 5dba 	jsr 45dba <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d6a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
        return
   45d6e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d74:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45d76:	4e75           	rts                                               	<== NOT EXECUTED
  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
        mutex_status = _CORE_mutex_Surrender(
   45d78:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45d7a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d7c:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   45d80:	4eb9 0004 6958 	jsr 46958 <_CORE_mutex_Surrender>                 	<== NOT EXECUTED
   45d86:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
   45d88:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
   45d8e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d90:	4eb9 0004 5da4 	jsr 45da4 <_Semaphore_Translate_core_mutex_return_code>	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d96:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
   45d9a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45da0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45da2:	4e75           	rts

0004632c <rtems_shutdown_executive>:
 */

void rtems_shutdown_executive(
   uint32_t   result
)
{
   4632c:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
  if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
   46330:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   46332:	b0b9 0005 88e6 	cmpl 588e6 <_System_state_Current>,%d0            	<== NOT EXECUTED
   46338:	6718           	beqs 46352 <rtems_shutdown_executive+0x26>        	<== 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 );
   4633a:	4879 0005 8720 	pea 58720 <_Thread_BSP_context>                   	<== NOT EXECUTED
   46340:	486e ffcc      	pea %fp@(-52)                                     	<== NOT EXECUTED
   46344:	23c0 0005 88e6 	movel %d0,588e6 <_System_state_Current>           	<== NOT EXECUTED
   4634a:	4eb9 0004 921c 	jsr 4921c <_CPU_Context_switch>                   	<== NOT EXECUTED
   46350:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    _System_state_Set( SYSTEM_STATE_SHUTDOWN );
    _Thread_Stop_multitasking();
  }
}
   46352:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46354:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046a30 <rtems_signal_catch>:
  RTEMS_API_Control  *api;
  ASR_Information    *asr;

/* XXX normalize mode */
  executing = _Thread_Executing;
  api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
   46a30:	2079 0005 a98a 	moveal 5a98a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46a36:	2039 0005 a8cc 	movel 5a8cc <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED

rtems_status_code rtems_signal_catch(
  rtems_asr_entry   asr_handler,
  rtems_mode        mode_set
)
{
   46a3c:	4e56 0000      	linkw %fp,#0                                      	<== 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 ];
   46a40:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED

rtems_status_code rtems_signal_catch(
  rtems_asr_entry   asr_handler,
  rtems_mode        mode_set
)
{
   46a44:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   46a48:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46a4a:	23c0 0005 a8cc 	movel %d0,5a8cc <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  asr = &api->Signal;

  _Thread_Disable_dispatch(); /* cannot reschedule while */
                              /*   the thread is inconsistent */

  if ( !_ASR_Is_null_handler( asr_handler ) ) {
   46a50:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   46a52:	6716           	beqs 46a6a <rtems_signal_catch+0x3a>              	<== NOT EXECUTED
    asr->mode_set = mode_set;
    asr->handler = asr_handler;
   46a54:	2141 000a      	movel %d1,%a0@(10)                                	<== NOT EXECUTED

  _Thread_Disable_dispatch(); /* cannot reschedule while */
                              /*   the thread is inconsistent */

  if ( !_ASR_Is_null_handler( asr_handler ) ) {
    asr->mode_set = mode_set;
   46a58:	216e 000c 000e 	movel %fp@(12),%a0@(14)                           	<== NOT EXECUTED
    asr->handler = asr_handler;
  }
  else
    _ASR_Initialize( asr );
  _Thread_Enable_dispatch();
   46a5e:	4eb9 0004 8c60 	jsr 48c60 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46a64:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46a66:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46a68:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
   46a6a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46a6c:	1140 0008      	moveb %d0,%a0@(8)                                 	<== NOT EXECUTED
  information->handler         = NULL;
  information->mode_set        = RTEMS_DEFAULT_MODES;
  information->signals_posted  = 0;
  information->signals_pending = 0;
  information->nest_level      = 0;
   46a70:	42a8 001a      	clrl %a0@(26)                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
  information->handler         = NULL;
   46a74:	42a8 000a      	clrl %a0@(10)                                     	<== NOT EXECUTED
  information->mode_set        = RTEMS_DEFAULT_MODES;
   46a78:	42a8 000e      	clrl %a0@(14)                                     	<== NOT EXECUTED
  information->signals_posted  = 0;
   46a7c:	42a8 0012      	clrl %a0@(18)                                     	<== NOT EXECUTED
  information->signals_pending = 0;
   46a80:	42a8 0016      	clrl %a0@(22)                                     	<== NOT EXECUTED
    asr->mode_set = mode_set;
    asr->handler = asr_handler;
  }
  else
    _ASR_Initialize( asr );
  _Thread_Enable_dispatch();
   46a84:	4eb9 0004 8c60 	jsr 48c60 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46a8a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46a8c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46a8e:	4e75           	rts

00052518 <rtems_signal_send>:

rtems_status_code rtems_signal_send(
  Objects_Id        id,
  rtems_signal_set  signal_set
)
{
   52518:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;

  if ( !signal_set )
   5251c:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   52520:	6606           	bnes 52528 <rtems_signal_send+0x10>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52522:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;

  if ( !signal_set )
   52524:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52526:	4e75           	rts                                               	<== NOT EXECUTED
  ASR_Information         *asr;

  if ( !signal_set )
    return RTEMS_INVALID_NUMBER;

  the_thread = _Thread_Get( id, &location );
   52528:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5252c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52530:	4eb9 0005 62cc 	jsr 562cc <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   52536:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  ASR_Information         *asr;

  if ( !signal_set )
    return RTEMS_INVALID_NUMBER;

  the_thread = _Thread_Get( id, &location );
   52538:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
  switch ( location ) {
   5253a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5253e:	6706           	beqs 52546 <rtems_signal_send+0x2e>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52540:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !signal_set )
    return RTEMS_INVALID_NUMBER;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   52542:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52544:	4e75           	rts                                               	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
   52546:	2069 010c      	moveal %a1@(268),%a0                              	<== NOT EXECUTED
      asr = &api->Signal;

      if ( ! _ASR_Is_null_handler( asr->handler ) ) {
   5254a:	4aa8 000a      	tstl %a0@(10)                                     	<== NOT EXECUTED
   5254e:	6770           	beqs 525c0 <rtems_signal_send+0xa8>               	<== NOT EXECUTED
        if ( asr->is_enabled ) {
   52550:	4a28 0008      	tstb %a0@(8)                                      	<== NOT EXECUTED
   52554:	673a           	beqs 52590 <rtems_signal_send+0x78>               	<== NOT EXECUTED
  rtems_signal_set *signal_set
)
{
  ISR_Level              _level;

  _ISR_Disable( _level );
   52556:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   5255c:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   5255e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   52560:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    *signal_set |= signals;
   52562:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   52566:	81a8 0012      	orl %d0,%a0@(18)                                  	<== NOT EXECUTED
  _ISR_Enable( _level );
   5256a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
          _ASR_Post_signals( signal_set, &asr->signals_posted );

          the_thread->do_post_task_switch_extension = true;

          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
   5256c:	2039 0007 169e 	movel 7169e <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED

      if ( ! _ASR_Is_null_handler( asr->handler ) ) {
        if ( asr->is_enabled ) {
          _ASR_Post_signals( signal_set, &asr->signals_posted );

          the_thread->do_post_task_switch_extension = true;
   52572:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   52574:	1341 0075      	moveb %d1,%a1@(117)                               	<== NOT EXECUTED

          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
   52578:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5257a:	6708           	beqs 52584 <rtems_signal_send+0x6c>               	<== NOT EXECUTED
   5257c:	b3f9 0007 16be 	cmpal 716be <_Thread_Executing>,%a1               	<== NOT EXECUTED
   52582:	672c           	beqs 525b0 <rtems_signal_send+0x98>               	<== NOT EXECUTED
            _ISR_Signals_to_thread_executing = TRUE;
        } else {
          _ASR_Post_signals( signal_set, &asr->signals_pending );
        }
        _Thread_Enable_dispatch();
   52584:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5258a:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5258c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5258e:	4e75           	rts                                               	<== NOT EXECUTED
  rtems_signal_set *signal_set
)
{
  ISR_Level              _level;

  _ISR_Disable( _level );
   52590:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   52596:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   52598:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   5259a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    *signal_set |= signals;
   5259c:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   525a0:	83a8 0016      	orl %d1,%a0@(22)                                  	<== NOT EXECUTED
  _ISR_Enable( _level );
   525a4:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
            _ISR_Signals_to_thread_executing = TRUE;
        } else {
          _ASR_Post_signals( signal_set, &asr->signals_pending );
        }
        _Thread_Enable_dispatch();
   525a6:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   525ac:	4280           	clrl %d0                                          	<== NOT EXECUTED
   525ae:	60dc           	bras 5258c <rtems_signal_send+0x74>               	<== NOT EXECUTED
          _ASR_Post_signals( signal_set, &asr->signals_posted );

          the_thread->do_post_task_switch_extension = true;

          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
            _ISR_Signals_to_thread_executing = TRUE;
   525b0:	13c1 0007 174c 	moveb %d1,7174c <_ISR_Signals_to_thread_executing>	<== NOT EXECUTED
        } else {
          _ASR_Post_signals( signal_set, &asr->signals_pending );
        }
        _Thread_Enable_dispatch();
   525b6:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   525bc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   525be:	60cc           	bras 5258c <rtems_signal_send+0x74>               	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   525c0:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   525c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          _ASR_Post_signals( signal_set, &asr->signals_pending );
        }
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   525c8:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   525ca:	4e75           	rts

00045dd0 <rtems_task_create>:
  size_t               stack_size,
  rtems_mode           initial_modes,
  rtems_attribute      attribute_set,
  Objects_Id          *id
)
{
   45dd0:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   45dd4:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   45dd8:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
  Priority_Control         core_priority;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;


  if ( !id )
   45ddc:	4aae 001c      	tstl %fp@(28)                                     	<== NOT EXECUTED
   45de0:	6700 0136      	beqw 45f18 <rtems_task_create+0x148>              	<== NOT EXECUTED
   return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   45de4:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   45de8:	6700 00ca      	beqw 45eb4 <rtems_task_create+0xe4>               	<== NOT EXECUTED

  /*
   *  Validate the RTEMS API priority and convert it to the core priority range.
   */

  if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
   45dec:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED
   45df0:	4a40           	tstw %d0                                          	<== NOT EXECUTED
   45df2:	6d18           	blts 45e0c <rtems_task_create+0x3c>               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
  rtems_task_priority the_priority
)
{
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
   45df4:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   45df8:	6700 00f8      	beqw 45ef2 <rtems_task_create+0x122>              	<== NOT EXECUTED
   45dfc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45dfe:	1039 0005 6c42 	moveb 56c42 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   45e04:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   45e08:	6500 00e8      	bcsw 45ef2 <rtems_task_create+0x122>              	<== NOT EXECUTED
   */

  /*
   *  Lock the allocator mutex for protection
   */
  _RTEMS_Lock_allocator();
   45e0c:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45e12:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED
 *  This function allocates a task control block from
 *  the inactive chain of free task control blocks.
 */
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
  return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
   45e18:	4879 0005 86c4 	pea 586c4 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   45e1e:	4eb9 0004 6f0c 	jsr 46f0c <_Objects_Allocate>                     	<== NOT EXECUTED
   *         the event of an error.
   */

  the_thread = _RTEMS_tasks_Allocate();

  if ( !the_thread ) {
   45e24:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45e26:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45e28:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45e2a:	6700 00d2      	beqw 45efe <rtems_task_create+0x12e>              	<== NOT EXECUTED

  /*
   *  Initialize the core thread for this task.
   */

  status = _Thread_Initialize(
   45e2e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45e32:	7207           	moveq #7,%d1                                      	<== NOT EXECUTED
   45e34:	c282           	andl %d2,%d1                                      	<== NOT EXECUTED
   45e36:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   45e38:	7609           	moveq #9,%d3                                      	<== NOT EXECUTED
   45e3a:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   45e3c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45e3e:	e6a9           	lsrl %d3,%d1                                      	<== NOT EXECUTED
   45e40:	163c 0001      	moveb #1,%d3                                      	<== NOT EXECUTED
   45e44:	c681           	andl %d1,%d3                                      	<== NOT EXECUTED
   45e46:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45e48:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45e4a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45e4c:	e088           	lsrl #8,%d0                                       	<== NOT EXECUTED
   45e4e:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   45e50:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   45e52:	c680           	andl %d0,%d3                                      	<== NOT EXECUTED
   45e54:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45e56:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45e58:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   45e5c:	c0ae 0018      	andl %fp@(24),%d0                                 	<== NOT EXECUTED
   45e60:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45e62:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   45e66:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45e68:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45e6a:	4879 0005 86c4 	pea 586c4 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   45e70:	4eb9 0004 7d90 	jsr 47d90 <_Thread_Initialize>                    	<== NOT EXECUTED
    NULL,        /* no budget algorithm callout */
    _Modes_Get_interrupt_level(initial_modes),
    (Objects_Name) name
  );

  if ( !status ) {
   45e76:	dffc 0000 002c 	addal #44,%sp                                     	<== NOT EXECUTED
   45e7c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45e7e:	6740           	beqs 45ec0 <rtems_task_create+0xf0>               	<== NOT EXECUTED
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;

  *id = the_thread->Object.id;
   45e80:	226e 001c      	moveal %fp@(28),%a1                               	<== NOT EXECUTED
  }

  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
   45e84:	720a           	moveq #10,%d1                                     	<== NOT EXECUTED
   45e86:	206a 010c      	moveal %a2@(268),%a0                              	<== NOT EXECUTED
   45e8a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45e8c:	e2aa           	lsrl %d1,%d2                                      	<== NOT EXECUTED

  *id = the_thread->Object.id;
   45e8e:	22aa 0008      	movel %a2@(8),%a1@                                	<== NOT EXECUTED
  }

  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
   45e92:	b182           	eorl %d0,%d2                                      	<== NOT EXECUTED
   45e94:	c480           	andl %d0,%d2                                      	<== NOT EXECUTED
   45e96:	1142 0008      	moveb %d2,%a0@(8)                                 	<== NOT EXECUTED
    );

   }
#endif

  _RTEMS_Unlock_allocator();
   45e9a:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45ea0:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   45ea6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45ea8:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45eae:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    );

   }
#endif

  _RTEMS_Unlock_allocator();
   45eb0:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45eb2:	4e75           	rts                                               	<== NOT EXECUTED
   45eb4:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45eba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  if ( !id )
   return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   45ebc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45ebe:	4e75           	rts                                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
  Thread_Control *the_task
)
{
  _Objects_Free(
   45ec0:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   45ec4:	4eb9 0004 7350 	jsr 47350 <_Objects_Get_information_id>           	<== NOT EXECUTED
   45eca:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45ecc:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45ece:	4eb9 0004 72cc 	jsr 472cc <_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();
   45ed4:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45eda:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   45ee0:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45ee6:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45eec:	4e5e           	unlk %fp                                          	<== 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();
   45eee:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45ef0:	4e75           	rts                                               	<== NOT EXECUTED
   45ef2:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45ef8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
   45efa:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
}
   45efc:	4e75           	rts                                               	<== NOT EXECUTED
   */

  the_thread = _RTEMS_tasks_Allocate();

  if ( !the_thread ) {
    _RTEMS_Unlock_allocator();
   45efe:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45f04:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   45f0a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45f0c:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45f12:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */

  the_thread = _RTEMS_tasks_Allocate();

  if ( !the_thread ) {
    _RTEMS_Unlock_allocator();
   45f14:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45f16:	4e75           	rts                                               	<== NOT EXECUTED
   45f18:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   45f1e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Priority_Control         core_priority;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;


  if ( !id )
   45f20:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   }
#endif

  _RTEMS_Unlock_allocator();
  return RTEMS_SUCCESSFUL;
}
   45f22:	4e75           	rts

00045f24 <rtems_task_delete>:
 */

rtems_status_code rtems_task_delete(
  Objects_Id id
)
{
   45f24:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45f28:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45f2a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  Objects_Information     *the_information;

  _RTEMS_Lock_allocator();
   45f2c:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45f32:	4eb9 0004 6640 	jsr 46640 <_API_Mutex_Lock>                       	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
   45f38:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45f3c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45f40:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   45f46:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  Objects_Locations        location;
  Objects_Information     *the_information;

  _RTEMS_Lock_allocator();

  the_thread = _Thread_Get( id, &location );
   45f4c:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
  switch ( location ) {
   45f4e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45f52:	664c           	bnes 45fa0 <rtems_task_delete+0x7c>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_information = _Objects_Get_information_id( the_thread->Object.id );
   45f54:	2f2b 0008      	movel %a3@(8),%sp@-                               	<== NOT EXECUTED
   45f58:	45f9 0004 7350 	lea 47350 <_Objects_Get_information_id>,%a2       	<== NOT EXECUTED
   45f5e:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
            0                                /* Not used */
          );
        }
      #endif

      _Thread_Close( the_information, the_thread );
   45f60:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45f62:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45f64:	4eb9 0004 7990 	jsr 47990 <_Thread_Close>                         	<== NOT EXECUTED
   45f6a:	2f2b 0008      	movel %a3@(8),%sp@-                               	<== NOT EXECUTED
   45f6e:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   45f70:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45f72:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45f74:	4eb9 0004 72cc 	jsr 472cc <_Objects_Free>                         	<== NOT EXECUTED

      _RTEMS_tasks_Free( the_thread );

      _RTEMS_Unlock_allocator();
   45f7a:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45f80:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   45f86:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      break;
  }

  _RTEMS_Unlock_allocator();
  return RTEMS_INVALID_ID;
}
   45f8c:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   45f90:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
      _Thread_Close( the_information, the_thread );

      _RTEMS_tasks_Free( the_thread );

      _RTEMS_Unlock_allocator();
      _Thread_Enable_dispatch();
   45f94:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
      break;
  }

  _RTEMS_Unlock_allocator();
  return RTEMS_INVALID_ID;
}
   45f9a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      _Thread_Close( the_information, the_thread );

      _RTEMS_tasks_Free( the_thread );

      _RTEMS_Unlock_allocator();
      _Thread_Enable_dispatch();
   45f9c:	4280           	clrl %d0                                          	<== NOT EXECUTED
      break;
  }

  _RTEMS_Unlock_allocator();
  return RTEMS_INVALID_ID;
}
   45f9e:	4e75           	rts                                               	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }

  _RTEMS_Unlock_allocator();
   45fa0:	2f39 0005 880a 	movel 5880a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45fa6:	4eb9 0004 66a4 	jsr 466a4 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return RTEMS_INVALID_ID;
}
   45fac:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   45fb0:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }

  _RTEMS_Unlock_allocator();
   45fb4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return RTEMS_INVALID_ID;
}
   45fb6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }

  _RTEMS_Unlock_allocator();
   45fb8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
  return RTEMS_INVALID_ID;
}
   45fba:	4e75           	rts

00047b54 <rtems_task_get_note>:
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47b54:	2079 0005 c5ee 	moveal 5c5ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47b5a:	2268 003e      	moveal %a0@(62),%a1                               	<== NOT EXECUTED
rtems_status_code rtems_task_get_note(
  Objects_Id  id,
  uint32_t    notepad,
  uint32_t   *note
)
{
   47b5e:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47b62:	4a29 0004      	tstb %a1@(4)                                      	<== NOT EXECUTED
   47b66:	6762           	beqs 47bca <rtems_task_get_note+0x76>             	<== NOT EXECUTED
    return RTEMS_NOT_CONFIGURED;

  if ( !note )
   47b68:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   47b6c:	6700 0084      	beqw 47bf2 <rtems_task_get_note+0x9e>             	<== 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 )
   47b70:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
   47b72:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   47b76:	654a           	bcss 47bc2 <rtems_task_get_note+0x6e>             	<== NOT EXECUTED

  /*
   *  Optimize the most likely case to avoid the Thread_Dispatch.
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
   47b78:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   47b7c:	6752           	beqs 47bd0 <rtems_task_get_note+0x7c>             	<== NOT EXECUTED
   47b7e:	2079 0005 c612 	moveal 5c612 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   47b84:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   47b88:	b3e8 0008      	cmpal %a0@(8),%a1                                 	<== NOT EXECUTED
   47b8c:	6748           	beqs 47bd6 <rtems_task_get_note+0x82>             	<== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   47b8e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   47b92:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47b96:	4eb9 0004 9b94 	jsr 49b94 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   47b9c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   47b9e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   47ba0:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   47ba4:	6646           	bnes 47bec <rtems_task_get_note+0x98>             	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
   47ba6:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   47baa:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
   47bae:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   47bb2:	22b0 0c1e      	movel %a0@(0000001e,%d0:l:4),%a1@                 	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   47bb6:	4eb9 0004 9b6c 	jsr 49b6c <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bbc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
      _Thread_Enable_dispatch();
   47bbe:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bc0:	4e75           	rts                                               	<== NOT EXECUTED
   47bc2:	4e5e           	unlk %fp                                          	<== 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 )
   47bc4:	103c 000a      	moveb #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bc8:	4e75           	rts                                               	<== NOT EXECUTED
   47bca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47bcc:	7016           	moveq #22,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bce:	4e75           	rts                                               	<== NOT EXECUTED
   47bd0:	2079 0005 c612 	moveal 5c612 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
   47bd6:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   47bda:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
   47bde:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   47be2:	22b0 0c1e      	movel %a0@(0000001e,%d0:l:4),%a1@                 	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47be6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
   47be8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bea:	4e75           	rts                                               	<== NOT EXECUTED
   47bec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      *note = api->Notepads[ notepad ];
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   47bee:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bf0:	4e75           	rts                                               	<== NOT EXECUTED
   47bf2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
    return RTEMS_NOT_CONFIGURED;

  if ( !note )
   47bf4:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47bf6:	4e75           	rts

00045fbc <rtems_task_ident>:
rtems_status_code rtems_task_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   45fbc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45fc0:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  if ( !id )
   45fc4:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   45fc6:	6740           	beqs 46008 <rtems_task_ident+0x4c>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( name == OBJECTS_ID_OF_SELF ) {
   45fc8:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   45fcc:	6610           	bnes 45fde <rtems_task_ident+0x22>                	<== NOT EXECUTED
    *id = _Thread_Executing->Object.id;
   45fce:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   }

  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );

  return _Status_Object_name_errors_to_status[ status ];
}
   45fd4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !id )
    return RTEMS_INVALID_ADDRESS;

  if ( name == OBJECTS_ID_OF_SELF ) {
    *id = _Thread_Executing->Object.id;
   45fd6:	22a8 0008      	movel %a0@(8),%a1@                                	<== NOT EXECUTED
   45fda:	4280           	clrl %d0                                          	<== NOT EXECUTED
   }

  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );

  return _Status_Object_name_errors_to_status[ status ];
}
   45fdc:	4e75           	rts                                               	<== NOT EXECUTED
  if ( name == OBJECTS_ID_OF_SELF ) {
    *id = _Thread_Executing->Object.id;
    return RTEMS_SUCCESSFUL;
   }

  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
   45fde:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   45fe0:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   45fe4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45fe8:	4879 0005 86c4 	pea 586c4 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   45fee:	4eb9 0004 75d0 	jsr 475d0 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
   45ff4:	41f9 0005 5c56 	lea 55c56 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
   45ffa:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   45ffe:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   46004:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46006:	4e75           	rts                                               	<== NOT EXECUTED
   46008:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id   *id
)
{
  Objects_Name_or_id_lookup_errors  status;

  if ( !id )
   4600a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   }

  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );

  return _Status_Object_name_errors_to_status[ status ];
}
   4600c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046468 <rtems_task_is_suspended>:
 */

rtems_status_code rtems_task_is_suspended(
  Objects_Id id
)
{
   46468:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   4646c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46470:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46474:	4eb9 0004 80b8 	jsr 480b8 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4647a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   4647c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   4647e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46482:	6706           	beqs 4648a <rtems_task_is_suspended+0x22>         	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46484:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   46486:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46488:	4e75           	rts                                               	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
   4648a:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4648c:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   46490:	670c           	beqs 4649e <rtems_task_is_suspended+0x36>         	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   46492:	4eb9 0004 8090 	jsr 48090 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46498:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4649a:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4649c:	4e75           	rts                                               	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Enable_dispatch();
   4649e:	4eb9 0004 8090 	jsr 48090 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   464a4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Enable_dispatch();
   464a6:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   464a8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004c094 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
  rtems_mode  mode_set,
  rtems_mode  mask,
  rtems_mode *previous_mode_set
)
{
   4c094:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4c098:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4c09c:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   4c0a0:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4c0a4:	286e 0010      	moveal %fp@(16),%a4                               	<== NOT EXECUTED
  ASR_Information    *asr;
  bool                is_asr_enabled = false;
  bool                needs_asr_dispatching = false;
  rtems_mode          old_mode;

  if ( !previous_mode_set )
   4c0a8:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4c0aa:	6700 015c      	beqw 4c208 <rtems_task_mode+0x174>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  executing     = _Thread_Executing;
   4c0ae:	2479 0005 8812 	moveal 58812 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  api = executing->API_Extensions[ THREAD_API_RTEMS ];
   4c0b4:	266a 010c      	moveal %a2@(268),%a3                              	<== NOT EXECUTED
  asr = &api->Signal;

  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
   4c0b8:	263c 0000 0100 	movel #256,%d3                                    	<== NOT EXECUTED
   4c0be:	4a2a 0076      	tstb %a2@(118)                                    	<== NOT EXECUTED
   4c0c2:	6600 00f6      	bnew 4c1ba <rtems_task_mode+0x126>                	<== NOT EXECUTED

  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
   4c0c6:	4aaa 007c      	tstl %a2@(124)                                    	<== NOT EXECUTED
   4c0ca:	6600 00f8      	bnew 4c1c4 <rtems_task_mode+0x130>                	<== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;
  else
    old_mode |= RTEMS_TIMESLICE;

  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
   4c0ce:	243c 0000 0400 	movel #1024,%d2                                   	<== NOT EXECUTED
   4c0d4:	4a2b 0008      	tstb %a3@(8)                                      	<== NOT EXECUTED
   4c0d8:	6600 00c6      	bnew 4c1a0 <rtems_task_mode+0x10c>                	<== NOT EXECUTED
  old_mode |= _ISR_Get_level();
   4c0dc:	4eb9 0004 92e8 	jsr 492e8 <_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;
   4c0e2:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
  old_mode |= _ISR_Get_level();

  *previous_mode_set = old_mode;
   4c0e4:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
   4c0e6:	2882           	movel %d2,%a4@                                    	<== NOT EXECUTED

  /*
   *  These are generic thread scheduling characteristics.
   */

  if ( mask & RTEMS_PREEMPT_MASK )
   4c0e8:	0804 0008      	btst #8,%d4                                       	<== NOT EXECUTED
   4c0ec:	670e           	beqs 4c0fc <rtems_task_mode+0x68>                 	<== NOT EXECUTED
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
   4c0ee:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4c0f0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4c0f2:	e088           	lsrl #8,%d0                                       	<== NOT EXECUTED
   4c0f4:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   4c0f6:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4c0f8:	1540 0076      	moveb %d0,%a2@(118)                               	<== NOT EXECUTED

  if ( mask & RTEMS_TIMESLICE_MASK ) {
   4c0fc:	0804 0009      	btst #9,%d4                                       	<== NOT EXECUTED
   4c100:	6718           	beqs 4c11a <rtems_task_mode+0x86>                 	<== NOT EXECUTED
    if ( _Modes_Is_timeslice(mode_set) ) {
   4c102:	0805 0009      	btst #9,%d5                                       	<== NOT EXECUTED
   4c106:	6700 00d0      	beqw 4c1d8 <rtems_task_mode+0x144>                	<== NOT EXECUTED
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
   4c10a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
   4c10c:	41f9 0005 8704 	lea 58704 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
  if ( mask & RTEMS_PREEMPT_MASK )
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;

  if ( mask & RTEMS_TIMESLICE_MASK ) {
    if ( _Modes_Is_timeslice(mode_set) ) {
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
   4c112:	2540 007c      	movel %d0,%a2@(124)                               	<== NOT EXECUTED
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
   4c116:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED

  /*
   *  Set the new interrupt level
   */

  if ( mask & RTEMS_INTERRUPT_MASK )
   4c11a:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   4c11c:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   4c11e:	6712           	beqs 4c132 <rtems_task_mode+0x9e>                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
  Modes_Control mode_set
)
{
  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
   4c120:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4c122:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   4c124:	c085           	andl %d5,%d0                                      	<== NOT EXECUTED
   4c126:	e188           	lsll #8,%d0                                       	<== NOT EXECUTED
   4c128:	0281 0000 f8ff 	andil #63743,%d1                                  	<== NOT EXECUTED
   4c12e:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4c130:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   */

  is_asr_enabled = FALSE;
  needs_asr_dispatching = FALSE;

  if ( mask & RTEMS_ASR_MASK ) {
   4c132:	0804 000a      	btst #10,%d4                                      	<== NOT EXECUTED
   4c136:	675a           	beqs 4c192 <rtems_task_mode+0xfe>                 	<== NOT EXECUTED
   4c138:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4c13a:	2205           	movel %d5,%d1                                     	<== NOT EXECUTED
   4c13c:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   4c13e:	103c 0001      	moveb #1,%d0                                      	<== NOT EXECUTED
   4c142:	b181           	eorl %d0,%d1                                      	<== NOT EXECUTED
   4c144:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {
   4c146:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4c148:	102b 0008      	moveb %a3@(8),%d0                                 	<== NOT EXECUTED
   4c14c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4c14e:	6742           	beqs 4c192 <rtems_task_mode+0xfe>                 	<== NOT EXECUTED
      asr->is_enabled = is_asr_enabled;
   4c150:	1741 0008      	moveb %d1,%a3@(8)                                 	<== NOT EXECUTED
)
{
  rtems_signal_set _signals;
  ISR_Level        _level;

  _ISR_Disable( _level );
   4c154:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4c15a:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4c15c:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4c15e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _signals                     = information->signals_pending;
   4c160:	202b 0016      	movel %a3@(22),%d0                                	<== NOT EXECUTED
    information->signals_pending = information->signals_posted;
   4c164:	276b 0012 0016 	movel %a3@(18),%a3@(22)                           	<== NOT EXECUTED
    information->signals_posted  = _signals;
   4c16a:	2740 0012      	movel %d0,%a3@(18)                                	<== NOT EXECUTED
  _ISR_Enable( _level );
   4c16e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      _ASR_Swap_signals( asr );
      if ( _ASR_Are_signals_pending( asr ) ) {
   4c170:	4aab 0012      	tstl %a3@(18)                                     	<== NOT EXECUTED
   4c174:	671c           	beqs 4c192 <rtems_task_mode+0xfe>                 	<== NOT EXECUTED
        needs_asr_dispatching = true;
        executing->do_post_task_switch_extension = true;
   4c176:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4c178:	1542 0075      	moveb %d2,%a2@(117)                               	<== NOT EXECUTED
      }
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
   4c17c:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4c17e:	b2b9 0005 88e6 	cmpl 588e6 <_System_state_Current>,%d1            	<== NOT EXECUTED
   4c184:	6762           	beqs 4c1e8 <rtems_task_mode+0x154>                	<== NOT EXECUTED
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
      _Thread_Dispatch();

  return RTEMS_SUCCESSFUL;
}
   4c186:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4c18c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
      _Thread_Dispatch();
   4c18e:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   4c190:	4e75           	rts                                               	<== NOT EXECUTED
    if ( is_asr_enabled != asr->is_enabled ) {
      asr->is_enabled = is_asr_enabled;
      _ASR_Swap_signals( asr );
      if ( _ASR_Are_signals_pending( asr ) ) {
        needs_asr_dispatching = true;
        executing->do_post_task_switch_extension = true;
   4c192:	4202           	clrb %d2                                          	<== NOT EXECUTED
      }
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
   4c194:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4c196:	b2b9 0005 88e6 	cmpl 588e6 <_System_state_Current>,%d1            	<== NOT EXECUTED
   4c19c:	66e8           	bnes 4c186 <rtems_task_mode+0xf2>                 	<== NOT EXECUTED
   4c19e:	6048           	bras 4c1e8 <rtems_task_mode+0x154>                	<== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;
  else
    old_mode |= RTEMS_TIMESLICE;

  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
  old_mode |= _ISR_Get_level();
   4c1a0:	4eb9 0004 92e8 	jsr 492e8 <_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;
   4c1a6:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4c1a8:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
  old_mode |= _ISR_Get_level();

  *previous_mode_set = old_mode;
   4c1aa:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
   4c1ac:	2882           	movel %d2,%a4@                                    	<== NOT EXECUTED

  /*
   *  These are generic thread scheduling characteristics.
   */

  if ( mask & RTEMS_PREEMPT_MASK )
   4c1ae:	0804 0008      	btst #8,%d4                                       	<== NOT EXECUTED
   4c1b2:	6700 ff48      	beqw 4c0fc <rtems_task_mode+0x68>                 	<== NOT EXECUTED
   4c1b6:	6000 ff36      	braw 4c0ee <rtems_task_mode+0x5a>                 	<== NOT EXECUTED

  executing     = _Thread_Executing;
  api = executing->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
   4c1ba:	4283           	clrl %d3                                          	<== NOT EXECUTED

  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
   4c1bc:	4aaa 007c      	tstl %a2@(124)                                    	<== NOT EXECUTED
   4c1c0:	6700 ff0c      	beqw 4c0ce <rtems_task_mode+0x3a>                 	<== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;
  else
    old_mode |= RTEMS_TIMESLICE;
   4c1c4:	08c3 0009      	bset #9,%d3                                       	<== NOT EXECUTED

  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
   4c1c8:	243c 0000 0400 	movel #1024,%d2                                   	<== NOT EXECUTED
   4c1ce:	4a2b 0008      	tstb %a3@(8)                                      	<== NOT EXECUTED
   4c1d2:	6700 ff08      	beqw 4c0dc <rtems_task_mode+0x48>                 	<== NOT EXECUTED
   4c1d6:	60c8           	bras 4c1a0 <rtems_task_mode+0x10c>                	<== NOT EXECUTED

  /*
   *  Set the new interrupt level
   */

  if ( mask & RTEMS_INTERRUPT_MASK )
   4c1d8:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
  if ( mask & RTEMS_TIMESLICE_MASK ) {
    if ( _Modes_Is_timeslice(mode_set) ) {
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
    } else
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
   4c1da:	42aa 007c      	clrl %a2@(124)                                    	<== NOT EXECUTED

  /*
   *  Set the new interrupt level
   */

  if ( mask & RTEMS_INTERRUPT_MASK )
   4c1de:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   4c1e0:	6700 ff50      	beqw 4c132 <rtems_task_mode+0x9e>                 	<== NOT EXECUTED
   4c1e4:	6000 ff3a      	braw 4c120 <rtems_task_mode+0x8c>                 	<== NOT EXECUTED
      }
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
   4c1e8:	4eb9 0004 c3b8 	jsr 4c3b8 <_Thread_Evaluate_mode>                 	<== NOT EXECUTED
   4c1ee:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4c1f0:	6604           	bnes 4c1f6 <rtems_task_mode+0x162>                	<== NOT EXECUTED
   4c1f2:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4c1f4:	6790           	beqs 4c186 <rtems_task_mode+0xf2>                 	<== NOT EXECUTED
      _Thread_Dispatch();
   4c1f6:	4eb9 0004 7b60 	jsr 47b60 <_Thread_Dispatch>                      	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   4c1fc:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4c202:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
      _Thread_Dispatch();
   4c204:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   4c206:	4e75           	rts                                               	<== NOT EXECUTED
   4c208:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4c20e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  ASR_Information    *asr;
  bool                is_asr_enabled = false;
  bool                needs_asr_dispatching = false;
  rtems_mode          old_mode;

  if ( !previous_mode_set )
   4c210:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  if ( _System_state_Is_up(_System_state_Current) )
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
      _Thread_Dispatch();

  return RTEMS_SUCCESSFUL;
}
   4c212:	4e75           	rts

00046988 <rtems_task_restart>:

rtems_status_code rtems_task_restart(
  Objects_Id id,
  uint32_t   argument
)
{
   46988:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   4698c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46990:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46994:	4eb9 0004 8628 	jsr 48628 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4699a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4699c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   469a0:	6624           	bnes 469c6 <rtems_task_restart+0x3e>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {
   469a2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   469a6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   469a8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   469aa:	4eb9 0004 8f5c 	jsr 48f5c <_Thread_Restart>                       	<== NOT EXECUTED
   469b0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   469b6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   469b8:	6612           	bnes 469cc <rtems_task_restart+0x44>              	<== NOT EXECUTED
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   469ba:	4eb9 0004 8600 	jsr 48600 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   469c0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   469c2:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   469c4:	4e75           	rts                                               	<== NOT EXECUTED
   469c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   469c8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   469ca:	4e75           	rts                                               	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {
        _Thread_Enable_dispatch();
   469cc:	4eb9 0004 8600 	jsr 48600 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   469d2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {
        _Thread_Enable_dispatch();
   469d4:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   469d6:	4e75           	rts

000472b0 <rtems_task_resume>:
 */

rtems_status_code rtems_task_resume(
  Objects_Id id
)
{
   472b0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   472b4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   472b8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   472bc:	4eb9 0004 91ec 	jsr 491ec <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   472c2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   472c4:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   472c6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   472ca:	6706           	beqs 472d2 <rtems_task_resume+0x22>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472cc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   472ce:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472d0:	4e75           	rts                                               	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _States_Is_suspended( the_thread->current_state ) ) {
   472d2:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   472d4:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   472d8:	660c           	bnes 472e6 <rtems_task_resume+0x36>               	<== NOT EXECUTED
        _Thread_Resume( the_thread, TRUE );
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   472da:	4eb9 0004 9194 	jsr 49194 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      if ( _States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Resume( the_thread, TRUE );
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   472e2:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472e4:	4e75           	rts                                               	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Resume( the_thread, TRUE );
   472e6:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   472ea:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   472ec:	4eb9 0004 9b20 	jsr 49b20 <_Thread_Resume>                        	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   472f2:	4eb9 0004 9194 	jsr 49194 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   472f8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Resume( the_thread, TRUE );
        _Thread_Enable_dispatch();
   472fc:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   472fe:	4e75           	rts

00062cd0 <rtems_task_self>:

#include <rtems/system.h>
#include <rtems/rtems/tasks.h>

rtems_id rtems_task_self(void)
{
   62cd0:	2079 0009 9f3e 	moveal 99f3e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   62cd6:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Thread_Executing->Object.id;
}
   62cda:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
   62cde:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   62ce0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047cf0 <rtems_task_set_note>:
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47cf0:	2079 0005 c5ee 	moveal 5c5ee <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47cf6:	2268 003e      	moveal %a0@(62),%a1                               	<== NOT EXECUTED
rtems_status_code rtems_task_set_note(
  Objects_Id id,
  uint32_t   notepad,
  uint32_t   note
)
{
   47cfa:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47cfe:	4a29 0004      	tstb %a1@(4)                                      	<== NOT EXECUTED
   47d02:	675a           	beqs 47d5e <rtems_task_set_note+0x6e>             	<== 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 )
   47d04:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
   47d06:	b0ae 000c      	cmpl %fp@(12),%d0                                 	<== NOT EXECUTED
   47d0a:	654a           	bcss 47d56 <rtems_task_set_note+0x66>             	<== NOT EXECUTED

  /*
   *  Optimize the most likely case to avoid the Thread_Dispatch.
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
   47d0c:	4aae 0008      	tstl %fp@(8)                                      	<== NOT EXECUTED
   47d10:	6752           	beqs 47d64 <rtems_task_set_note+0x74>             	<== NOT EXECUTED
   47d12:	2079 0005 c612 	moveal 5c612 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   47d18:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   47d1c:	b2a8 0008      	cmpl %a0@(8),%d1                                  	<== NOT EXECUTED
   47d20:	6748           	beqs 47d6a <rtems_task_set_note+0x7a>             	<== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   47d22:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   47d26:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47d2a:	4eb9 0004 9b94 	jsr 49b94 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   47d30:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   47d32:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   47d34:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   47d38:	6646           	bnes 47d80 <rtems_task_set_note+0x90>             	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
   47d3a:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   47d3e:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   47d42:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   47d46:	2181 0c1e      	movel %d1,%a0@(0000001e,%d0:l:4)                  	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   47d4a:	4eb9 0004 9b6c 	jsr 49b6c <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d50:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
      _Thread_Enable_dispatch();
   47d52:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d54:	4e75           	rts                                               	<== NOT EXECUTED
   47d56:	4e5e           	unlk %fp                                          	<== 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 )
   47d58:	103c 000a      	moveb #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d5c:	4e75           	rts                                               	<== NOT EXECUTED
   47d5e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   47d60:	7016           	moveq #22,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d62:	4e75           	rts                                               	<== NOT EXECUTED
   47d64:	2079 0005 c612 	moveal 5c612 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
   47d6a:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   47d6e:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   47d72:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d76:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
   47d78:	2181 0c1e      	movel %d1,%a0@(0000001e,%d0:l:4)                  	<== NOT EXECUTED
   47d7c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d7e:	4e75           	rts                                               	<== NOT EXECUTED
   47d80:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      api->Notepads[ notepad ] = note;
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   47d82:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   47d84:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004b758 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
  Objects_Id           id,
  rtems_task_priority  new_priority,
  rtems_task_priority *old_priority
)
{
   4b758:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4b75c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4b75e:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations               location;

  if ( new_priority != RTEMS_CURRENT_PRIORITY &&
   4b762:	670c           	beqs 4b770 <rtems_task_set_priority+0x18>         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
  rtems_task_priority the_priority
)
{
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
   4b764:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4b766:	1039 0006 4032 	moveb 64032 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   4b76c:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4b76e:	6566           	bcss 4b7d6 <rtems_task_set_priority+0x7e>         	<== NOT EXECUTED
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )
    return RTEMS_INVALID_PRIORITY;

  if ( !old_priority )
   4b770:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   4b774:	676a           	beqs 4b7e0 <rtems_task_set_priority+0x88>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   4b776:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4b77a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4b77e:	4eb9 0004 d614 	jsr 4d614 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4b784:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_PRIORITY;

  if ( !old_priority )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   4b786:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   4b788:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4b78c:	663e           	bnes 4b7cc <rtems_task_set_priority+0x74>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /* XXX need helper to "convert" from core priority */
      *old_priority = the_thread->current_priority;
   4b78e:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
   4b792:	22a8 0014      	movel %a0@(20),%a1@                               	<== NOT EXECUTED
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
   4b796:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4b798:	6722           	beqs 4b7bc <rtems_task_set_priority+0x64>         	<== NOT EXECUTED
        the_thread->real_priority = new_priority;
   4b79a:	2142 0018      	movel %d2,%a0@(24)                                	<== NOT EXECUTED
        if ( the_thread->resource_count == 0 ||
   4b79e:	4aa8 001c      	tstl %a0@(28)                                     	<== NOT EXECUTED
   4b7a2:	6706           	beqs 4b7aa <rtems_task_set_priority+0x52>         	<== NOT EXECUTED
   4b7a4:	b4a8 0014      	cmpl %a0@(20),%d2                                 	<== NOT EXECUTED
   4b7a8:	6412           	bccs 4b7bc <rtems_task_set_priority+0x64>         	<== NOT EXECUTED
             the_thread->current_priority > new_priority )
          _Thread_Change_priority( the_thread, new_priority, FALSE );
   4b7aa:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4b7ac:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4b7ae:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4b7b0:	4eb9 0004 d094 	jsr 4d094 <_Thread_Change_priority>               	<== NOT EXECUTED
   4b7b6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
      }
      _Thread_Enable_dispatch();
   4b7bc:	4eb9 0004 d5bc 	jsr 4d5bc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4b7c2:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4b7c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        the_thread->real_priority = new_priority;
        if ( the_thread->resource_count == 0 ||
             the_thread->current_priority > new_priority )
          _Thread_Change_priority( the_thread, new_priority, FALSE );
      }
      _Thread_Enable_dispatch();
   4b7c8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4b7ca:	4e75           	rts                                               	<== NOT EXECUTED
   4b7cc:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4b7d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !old_priority )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   4b7d2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4b7d4:	4e75           	rts                                               	<== NOT EXECUTED
   4b7d6:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4b7da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b7dc:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
   4b7de:	4e75           	rts                                               	<== NOT EXECUTED
   4b7e0:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4b7e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( new_priority != RTEMS_CURRENT_PRIORITY &&
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )
    return RTEMS_INVALID_PRIORITY;

  if ( !old_priority )
   4b7e6:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4b7e8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000460a4 <rtems_task_start>:
rtems_status_code rtems_task_start(
  rtems_id         	id,
  rtems_task_entry 	entry_point,
  rtems_task_argument	argument
)
{
   460a4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  if ( entry_point == NULL )
   460a8:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   460ac:	6752           	beqs 46100 <rtems_task_start+0x5c>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   460ae:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   460b2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   460b6:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   460bc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   460be:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   460c2:	662a           	bnes 460ee <rtems_task_start+0x4a>                	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _Thread_Start(
   460c4:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   460c8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   460ca:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   460ce:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   460d0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   460d2:	4eb9 0004 8920 	jsr 48920 <_Thread_Start>                         	<== NOT EXECUTED
   460d8:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   460de:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   460e0:	6612           	bnes 460f4 <rtems_task_start+0x50>                	<== NOT EXECUTED
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   460e2:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   460e8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      if ( _Thread_Start(
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   460ea:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   460ec:	4e75           	rts                                               	<== NOT EXECUTED
   460ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( entry_point == NULL )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   460f0:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   460f2:	4e75           	rts                                               	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _Thread_Start(
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();
   460f4:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   460fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( _Thread_Start(
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();
   460fc:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   460fe:	4e75           	rts                                               	<== NOT EXECUTED
   46100:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  if ( entry_point == NULL )
   46102:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46104:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046108 <rtems_task_suspend>:
 */

rtems_status_code rtems_task_suspend(
  Objects_Id id
)
{
   46108:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   4610c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46110:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46114:	4eb9 0004 7ce4 	jsr 47ce4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4611a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   4611c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   4611e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46122:	6706           	beqs 4612a <rtems_task_suspend+0x22>              	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46124:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {
   46126:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46128:	4e75           	rts                                               	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
   4612a:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4612c:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   46130:	670c           	beqs 4613e <rtems_task_suspend+0x36>              	<== NOT EXECUTED
        _Thread_Suspend( the_thread );
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   46132:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46138:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Suspend( the_thread );
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4613a:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4613c:	4e75           	rts                                               	<== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Suspend( the_thread );
   4613e:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46140:	4eb9 0004 897c 	jsr 4897c <_Thread_Suspend>                       	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   46146:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4614c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4614e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
        _Thread_Suspend( the_thread );
        _Thread_Enable_dispatch();
   46150:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46152:	4e75           	rts

00062f04 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
  rtems_id tid,
  void **ptr,
  void (*dtor)(void *)
)
{
   62f04:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   62f08:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   62f0a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   62f0c:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp, *new;

  if ( !ptr )
   62f10:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   62f12:	6700 008e      	beqw 62fa2 <rtems_task_variable_add+0x9e>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   62f16:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   62f1a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   62f1e:	4eb9 0004 c57c 	jsr 4c57c <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   62f24:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  rtems_task_variable_t *tvp, *new;

  if ( !ptr )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   62f26:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
  switch (location) {
   62f28:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   62f2c:	6652           	bnes 62f80 <rtems_task_variable_add+0x7c>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is already in this task's list.
       */
      tvp = the_thread->task_variables;
   62f2e:	206b 011c      	moveal %a3@(284),%a0                              	<== NOT EXECUTED
      while (tvp) {
   62f32:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   62f34:	670c           	beqs 62f42 <rtems_task_variable_add+0x3e>         	<== NOT EXECUTED
        if (tvp->ptr == ptr) {
   62f36:	b5e8 0004      	cmpal %a0@(4),%a2                                 	<== NOT EXECUTED
   62f3a:	6728           	beqs 62f64 <rtems_task_variable_add+0x60>         	<== NOT EXECUTED
          tvp->dtor = dtor;
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
   62f3c:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is already in this task's list.
       */
      tvp = the_thread->task_variables;
      while (tvp) {
   62f3e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   62f40:	66f4           	bnes 62f36 <rtems_task_variable_add+0x32>         	<== NOT EXECUTED
      }

      /*
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
   62f42:	4878 0014      	pea 14 <OPER2>                                    	<== NOT EXECUTED
   62f46:	4eb9 0004 d9f0 	jsr 4d9f0 <_Workspace_Allocate>                   	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
   62f4c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      }

      /*
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
   62f4e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
   62f50:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   62f52:	673a           	beqs 62f8e <rtems_task_variable_add+0x8a>         	<== NOT EXECUTED
      }
      new->gval = *ptr;
      new->ptr = ptr;
      new->dtor = dtor;

      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
   62f54:	20ab 011c      	movel %a3@(284),%a0@                              	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
        _Thread_Enable_dispatch();
        return RTEMS_NO_MEMORY;
      }
      new->gval = *ptr;
   62f58:	2152 0008      	movel %a2@,%a0@(8)                                	<== NOT EXECUTED
      new->ptr = ptr;
      new->dtor = dtor;

      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
      the_thread->task_variables = new;
   62f5c:	2740 011c      	movel %d0,%a3@(284)                               	<== NOT EXECUTED
      if (new == NULL) {
        _Thread_Enable_dispatch();
        return RTEMS_NO_MEMORY;
      }
      new->gval = *ptr;
      new->ptr = ptr;
   62f60:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
      new->dtor = dtor;
   62f64:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   62f68:	2140 0010      	movel %d0,%a0@(16)                                	<== NOT EXECUTED

      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
      the_thread->task_variables = new;
      _Thread_Enable_dispatch();
   62f6c:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   62f72:	4280           	clrl %d0                                          	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   62f74:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   62f78:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   62f7c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   62f7e:	4e75           	rts                                               	<== NOT EXECUTED
   62f80:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   62f84:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   62f88:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !ptr )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
  switch (location) {
   62f8a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   62f8c:	4e75           	rts                                               	<== NOT EXECUTED
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
        _Thread_Enable_dispatch();
   62f8e:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   62f94:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   62f98:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   62f9c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
        _Thread_Enable_dispatch();
   62f9e:	701a           	moveq #26,%d0                                     	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   62fa0:	4e75           	rts                                               	<== NOT EXECUTED
   62fa2:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   62fa6:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   62faa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp, *new;

  if ( !ptr )
   62fac:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   62fae:	4e75           	rts

00062fb0 <rtems_task_variable_delete>:

rtems_status_code rtems_task_variable_delete(
  rtems_id  tid,
  void    **ptr
)
{
   62fb0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   62fb4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   62fb6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   62fb8:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp, *prev;

  if ( !ptr )
   62fbc:	676a           	beqs 63028 <rtems_task_variable_delete+0x78>      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  prev = NULL;

  the_thread = _Thread_Get (tid, &location);
   62fbe:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   62fc2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   62fc6:	4eb9 0004 c57c 	jsr 4c57c <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   62fcc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  if ( !ptr )
    return RTEMS_INVALID_ADDRESS;

  prev = NULL;

  the_thread = _Thread_Get (tid, &location);
   62fce:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  switch (location) {
   62fd0:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   62fd4:	663e           	bnes 63014 <rtems_task_variable_delete+0x64>      	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      tvp = the_thread->task_variables;
   62fd6:	206a 011c      	moveal %a2@(284),%a0                              	<== NOT EXECUTED
      while (tvp) {
   62fda:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   62fdc:	6744           	beqs 63022 <rtems_task_variable_delete+0x72>      	<== NOT EXECUTED
        if (tvp->ptr == ptr) {
   62fde:	b4a8 0004      	cmpl %a0@(4),%d2                                  	<== NOT EXECUTED
   62fe2:	6752           	beqs 63036 <rtems_task_variable_delete+0x86>      	<== NOT EXECUTED
          else
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;

          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
   62fe4:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
        }
        prev = tvp;
        tvp = (rtems_task_variable_t *)tvp->next;
   62fe6:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
  the_thread = _Thread_Get (tid, &location);
  switch (location) {

    case OBJECTS_LOCAL:
      tvp = the_thread->task_variables;
      while (tvp) {
   62fe8:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   62fea:	6736           	beqs 63022 <rtems_task_variable_delete+0x72>      	<== NOT EXECUTED
        if (tvp->ptr == ptr) {
   62fec:	b4a8 0004      	cmpl %a0@(4),%d2                                  	<== NOT EXECUTED
   62ff0:	66f2           	bnes 62fe4 <rtems_task_variable_delete+0x34>      	<== NOT EXECUTED
          if (prev)
            prev->next = tvp->next;
   62ff2:	2290           	movel %a0@,%a1@                                   	<== NOT EXECUTED
          else
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;

          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
   62ff4:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   62ff6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   62ff8:	4eb9 0006 30cc 	jsr 630cc <_RTEMS_Tasks_Invoke_task_variable_dtor>	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   62ffe:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   63004:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   63006:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
        break;
  }

  return RTEMS_INVALID_ID;
}
   63008:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   6300c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   63010:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   63012:	4e75           	rts                                               	<== NOT EXECUTED
   63014:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   63018:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   6301c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  prev = NULL;

  the_thread = _Thread_Get (tid, &location);
  switch (location) {
   6301e:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
        break;
  }

  return RTEMS_INVALID_ID;
}
   63020:	4e75           	rts                                               	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        prev = tvp;
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   63022:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
        break;
  }

  return RTEMS_INVALID_ID;
}
   63028:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   6302c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   63030:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        prev = tvp;
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   63032:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
        break;
  }

  return RTEMS_INVALID_ID;
}
   63034:	4e75           	rts                                               	<== NOT EXECUTED
      while (tvp) {
        if (tvp->ptr == ptr) {
          if (prev)
            prev->next = tvp->next;
          else
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
   63036:	2550 011c      	movel %a0@,%a2@(284)                              	<== NOT EXECUTED

          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
   6303a:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   6303c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   6303e:	4eb9 0006 30cc 	jsr 630cc <_RTEMS_Tasks_Invoke_task_variable_dtor>	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   63044:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   6304a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   6304c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   6304e:	60b8           	bras 63008 <rtems_task_variable_delete+0x58>      	<== NOT EXECUTED

00063050 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
  rtems_id tid,
  void **ptr,
  void **result
)
{
   63050:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   63054:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   63056:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp;

  if ( !ptr )
   6305a:	674c           	beqs 630a8 <rtems_task_variable_get+0x58>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !result )
   6305c:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   63060:	6746           	beqs 630a8 <rtems_task_variable_get+0x58>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   63062:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   63066:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   6306a:	4eb9 0004 c57c 	jsr 4c57c <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   63070:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !result )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   63072:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch (location) {
   63074:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   63078:	6624           	bnes 6309e <rtems_task_variable_get+0x4e>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is in this task's list.
       */
      tvp = the_thread->task_variables;
   6307a:	2068 011c      	moveal %a0@(284),%a0                              	<== NOT EXECUTED
      while (tvp) {
   6307e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   63080:	670c           	beqs 6308e <rtems_task_variable_get+0x3e>         	<== NOT EXECUTED
        if (tvp->ptr == ptr) {
   63082:	b4a8 0004      	cmpl %a0@(4),%d2                                  	<== NOT EXECUTED
   63086:	672a           	beqs 630b2 <rtems_task_variable_get+0x62>         	<== NOT EXECUTED
	   */
          *result = tvp->tval;
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
   63088:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is in this task's list.
       */
      tvp = the_thread->task_variables;
      while (tvp) {
   6308a:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   6308c:	66f4           	bnes 63082 <rtems_task_variable_get+0x32>         	<== NOT EXECUTED
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   6308e:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   63094:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   63098:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   6309a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   6309c:	4e75           	rts                                               	<== NOT EXECUTED
   6309e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   630a2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !result )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
  switch (location) {
   630a4:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   630a6:	4e75           	rts                                               	<== NOT EXECUTED
   630a8:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   630ac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
      return RTEMS_INVALID_ADDRESS;
   630ae:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   630b0:	4e75           	rts                                               	<== NOT EXECUTED
        if (tvp->ptr == ptr) {
	  /*
	   * Should this return the current (i.e not the
	   * saved) value if `tid' is the current task?
	   */
          *result = tvp->tval;
   630b2:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
   630b6:	22a8 000c      	movel %a0@(12),%a1@                               	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   630ba:	4eb9 0004 c554 	jsr 4c554 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   630c0:	4280           	clrl %d0                                          	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   630c2:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   630c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   630c8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046154 <rtems_task_wake_after>:
 */

rtems_status_code rtems_task_wake_after(
  rtems_interval ticks
)
{
   46154:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46158:	2039 0005 8754 	movel 58754 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4615e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46160:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   46164:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46166:	23c0 0005 8754 	movel %d0,58754 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  _Thread_Disable_dispatch();
    if ( ticks == 0 ) {
   4616c:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4616e:	675a           	beqs 461ca <rtems_task_wake_after+0x76>           	<== NOT EXECUTED
      _Thread_Yield_processor();
    } else {
      _Thread_Set_state( _Thread_Executing, STATES_DELAYING );
   46170:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   46174:	2f39 0005 8812 	movel 58812 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   4617a:	4eb9 0004 8680 	jsr 48680 <_Thread_Set_state>                     	<== NOT EXECUTED
      _Watchdog_Initialize(
   46180:	2079 0005 8812 	moveal 58812 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46186:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4618a:	223c 0004 7b24 	movel #293668,%d1                                 	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46190:	2142 0054      	movel %d2,%a0@(84)                                	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   46194:	2140 0068      	movel %d0,%a0@(104)                               	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   46198:	2141 0064      	movel %d1,%a0@(100)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4619c:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   461a0:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   461a4:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   461a8:	4879 0005 8830 	pea 58830 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   461ae:	4eb9 0004 8ed4 	jsr 48ed4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   461b4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
        _Thread_Executing->Object.id,
        NULL
      );
      _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
    }
  _Thread_Enable_dispatch();
   461ba:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   461c0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   461c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   461c6:	4280           	clrl %d0                                          	<== NOT EXECUTED
   461c8:	4e75           	rts                                               	<== NOT EXECUTED
  rtems_interval ticks
)
{
  _Thread_Disable_dispatch();
    if ( ticks == 0 ) {
      _Thread_Yield_processor();
   461ca:	4eb9 0004 8b14 	jsr 48b14 <_Thread_Yield_processor>               	<== NOT EXECUTED
        _Thread_Executing->Object.id,
        NULL
      );
      _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
    }
  _Thread_Enable_dispatch();
   461d0:	4eb9 0004 7cbc 	jsr 47cbc <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   461d6:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   461da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   461dc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   461de:	4e75           	rts

00046ee0 <rtems_task_wake_when>:
 */

rtems_status_code rtems_task_wake_when(
  rtems_time_of_day *time_buffer
)
{
   46ee0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46ee4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46ee6:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  Watchdog_Interval   seconds;

  if ( !_TOD_Is_set )
   46eea:	4a39 0005 a638 	tstb 5a638 <_TOD_Is_set>                          	<== NOT EXECUTED
   46ef0:	6700 00a6      	beqw 46f98 <rtems_task_wake_when+0xb8>            	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !time_buffer )
   46ef4:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   46ef6:	6700 00aa      	beqw 46fa2 <rtems_task_wake_when+0xc2>            	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  time_buffer->ticks = 0;
   46efa:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED

  if ( !_TOD_Validate( time_buffer ) )
   46efe:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46f00:	4eb9 0004 61b8 	jsr 461b8 <_TOD_Validate>                         	<== NOT EXECUTED
   46f06:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46f08:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46f0a:	660a           	bnes 46f16 <rtems_task_wake_when+0x36>            	<== NOT EXECUTED
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46f0c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46f10:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _Watchdog_Insert_seconds(
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
   46f12:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
}
   46f14:	4e75           	rts                                               	<== NOT EXECUTED
  time_buffer->ticks = 0;

  if ( !_TOD_Validate( time_buffer ) )
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( time_buffer );
   46f16:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46f18:	4eb9 0004 6084 	jsr 46084 <_TOD_To_seconds>                       	<== NOT EXECUTED

  if ( seconds <= _TOD_Seconds_since_epoch )
   46f1e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  time_buffer->ticks = 0;

  if ( !_TOD_Validate( time_buffer ) )
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( time_buffer );
   46f20:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( seconds <= _TOD_Seconds_since_epoch )
   46f22:	b0b9 0005 a6b6 	cmpl 5a6b6 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   46f28:	63e2           	blss 46f0c <rtems_task_wake_when+0x2c>            	<== NOT EXECUTED
   46f2a:	2039 0005 a624 	movel 5a624 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46f30:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46f32:	23c0 0005 a624 	movel %d0,5a624 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  _Thread_Disable_dispatch();
    _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
   46f38:	4878 0010      	pea 10 <FP_STATE_SAVED>                           	<== NOT EXECUTED
   46f3c:	2f39 0005 a6e2 	movel 5a6e2 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   46f42:	4eb9 0004 9468 	jsr 49468 <_Thread_Set_state>                     	<== NOT EXECUTED
    _Watchdog_Initialize(
   46f48:	2079 0005 a6e2 	moveal 5a6e2 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46f4e:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   46f52:	2140 0068      	movel %d0,%a0@(104)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46f56:	95f9 0005 a6b6 	subal 5a6b6 <_TOD_Now>,%a2                        	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   46f5c:	203c 0004 890c 	movel #297228,%d0                                 	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46f62:	214a 0054      	movel %a2,%a0@(84)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   46f66:	2140 0064      	movel %d0,%a0@(100)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   46f6a:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   46f6e:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   46f72:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   46f76:	4879 0005 a6f4 	pea 5a6f4 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   46f7c:	4eb9 0004 9d50 	jsr 49d50 <_Watchdog_Insert>                      	<== NOT EXECUTED
    );
    _Watchdog_Insert_seconds(
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
   46f82:	4eb9 0004 8aa4 	jsr 48aa4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46f88:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
    );
    _Watchdog_Insert_seconds(
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
   46f8c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46f92:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    );
    _Watchdog_Insert_seconds(
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
   46f94:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   46f96:	4e75           	rts                                               	<== NOT EXECUTED
   46f98:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46f9c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  rtems_time_of_day *time_buffer
)
{
  Watchdog_Interval   seconds;

  if ( !_TOD_Is_set )
   46f9e:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46fa0:	4e75           	rts                                               	<== NOT EXECUTED
   46fa2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46fa6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Watchdog_Interval   seconds;

  if ( !_TOD_Is_set )
    return RTEMS_NOT_DEFINED;

  if ( !time_buffer )
   46fa8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   46faa:	4e75           	rts

00052d18 <rtems_timer_cancel>:
 */

rtems_status_code rtems_timer_cancel(
  Objects_Id id
)
{
   52d18:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   52d1c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52d20:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52d24:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52d2a:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control   *the_timer;
  Objects_Locations       location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52d30:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52d36:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   52d38:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   52d3c:	6706           	beqs 52d44 <rtems_timer_cancel+0x2c>              	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52d3e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control   *the_timer;
  Objects_Locations       location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52d40:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52d42:	4e75           	rts                                               	<== NOT EXECUTED

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
   52d44:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   52d46:	b0a8 0038      	cmpl %a0@(56),%d0                                 	<== NOT EXECUTED
   52d4a:	670c           	beqs 52d58 <rtems_timer_cancel+0x40>              	<== NOT EXECUTED
        (void) _Watchdog_Remove( &the_timer->Ticker );
   52d4c:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   52d50:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
   52d56:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   52d58:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52d5e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
        (void) _Watchdog_Remove( &the_timer->Ticker );
      _Thread_Enable_dispatch();
   52d60:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52d62:	4e75           	rts

00052d64 <rtems_timer_create>:

rtems_status_code rtems_timer_create(
  rtems_name    name,
  Objects_Id   *id
)
{
   52d64:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   52d68:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52d6a:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  Timer_Control *the_timer;

  if ( !rtems_is_name_valid( name ) )
   52d6e:	676a           	beqs 52dda <rtems_timer_create+0x76>              	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   52d70:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   52d74:	677e           	beqs 52df4 <rtems_timer_create+0x90>              	<== NOT EXECUTED
   52d76:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   52d7c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   52d7e:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 *  This function allocates a timer control block from
 *  the inactive chain of free timer control blocks.
 */
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
  return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
   52d84:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52d8a:	4eb9 0005 54b4 	jsr 554b4 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_timer = _Timer_Allocate();

  if ( !the_timer ) {
   52d90:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   52d92:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   52d94:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   52d96:	674c           	beqs 52de4 <rtems_timer_create+0x80>              	<== NOT EXECUTED
    &_Timer_Information,
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
   52d98:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   52d9c:	2342 000c      	movel %d2,%a1@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   52da0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   52da2:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   52da6:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED
  if ( !the_timer ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_timer->the_class = TIMER_DORMANT;
   52daa:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
    &_Timer_Information,
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
   52dac:	20a9 0008      	movel %a1@(8),%a0@                                	<== NOT EXECUTED
   52db0:	2079 0007 189c 	moveal 7189c <_Timer_Information+0x1a>,%a0        	<== NOT EXECUTED
  if ( !the_timer ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_timer->the_class = TIMER_DORMANT;
   52db6:	2341 0038      	movel %d1,%a1@(56)                                	<== NOT EXECUTED
   52dba:	2189 0c00      	movel %a1,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   52dbe:	42a9 0018      	clrl %a1@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   52dc2:	42a9 002c      	clrl %a1@(44)                                     	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   52dc6:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
   52dca:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   52dd0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   52dd4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
   52dd6:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   52dd8:	4e75           	rts                                               	<== NOT EXECUTED
   52dda:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   52dde:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id   *id
)
{
  Timer_Control *the_timer;

  if ( !rtems_is_name_valid( name ) )
   52de0:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   52de2:	4e75           	rts                                               	<== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_timer = _Timer_Allocate();

  if ( !the_timer ) {
    _Thread_Enable_dispatch();
   52de4:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   52dea:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   52dee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_timer = _Timer_Allocate();

  if ( !the_timer ) {
    _Thread_Enable_dispatch();
   52df0:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   52df2:	4e75           	rts                                               	<== NOT EXECUTED
   52df4:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   52df8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Timer_Control *the_timer;

  if ( !rtems_is_name_valid( name ) )
    return RTEMS_INVALID_NAME;

  if ( !id )
   52dfa:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
  return RTEMS_SUCCESSFUL;
}
   52dfc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052e00 <rtems_timer_delete>:
 */

rtems_status_code rtems_timer_delete(
  Objects_Id id
)
{
   52e00:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   52e04:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   52e06:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52e0a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52e0e:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52e14:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52e1a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52e20:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   52e22:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   52e26:	663c           	bnes 52e64 <rtems_timer_delete+0x64>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Timer_Information, &the_timer->Object );
   52e28:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   52e2a:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52e30:	4eb9 0005 5550 	jsr 55550 <_Objects_Close>                        	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_timer->Ticker );
   52e36:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   52e3a:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Timer_Free (
  Timer_Control *the_timer
)
{
  _Objects_Free( &_Timer_Information, &the_timer->Object );
   52e40:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   52e42:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52e48:	4eb9 0005 5874 	jsr 55874 <_Objects_Free>                         	<== NOT EXECUTED
      _Timer_Free( the_timer );
      _Thread_Enable_dispatch();
   52e4e:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52e54:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Timer_Information, &the_timer->Object );
      (void) _Watchdog_Remove( &the_timer->Ticker );
      _Timer_Free( the_timer );
      _Thread_Enable_dispatch();
   52e58:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52e5e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Timer_Information, &the_timer->Object );
      (void) _Watchdog_Remove( &the_timer->Ticker );
      _Timer_Free( the_timer );
      _Thread_Enable_dispatch();
   52e60:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52e62:	4e75           	rts                                               	<== NOT EXECUTED
   52e64:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52e68:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52e6a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52e6c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052e70 <rtems_timer_fire_after>:
  Objects_Id                         id,
  rtems_interval                     ticks,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   52e70:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   52e74:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   52e76:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Timer_Control      *the_timer;
  Objects_Locations   location;
  ISR_Level           level;

  if ( ticks == 0 )
   52e78:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   52e7c:	6700 00aa      	beqw 52f28 <rtems_timer_fire_after+0xb8>          	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  if ( !routine )
   52e80:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   52e84:	6700 00b0      	beqw 52f36 <rtems_timer_fire_after+0xc6>          	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   52e88:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52e8c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52e90:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52e96:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52e9c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52ea2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   52ea4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   52ea8:	6670           	bnes 52f1a <rtems_timer_fire_after+0xaa>          	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   52eaa:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   52eac:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   52eb2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52eb4:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED

      _ISR_Disable( level );
   52eba:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   52ec0:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   52ec2:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   52ec4:	46c0           	movew %d0,%sr                                     	<== 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 ) {
   52ec6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   52ec8:	4aaa 0018      	tstl %a2@(24)                                     	<== NOT EXECUTED
   52ecc:	6676           	bnes 52f44 <rtems_timer_fire_after+0xd4>          	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   52ece:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   52ed2:	2540 002c      	movel %d0,%a2@(44)                                	<== NOT EXECUTED
  the_watchdog->id        = id;
   52ed6:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   52eda:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   52ee0:	2540 0030      	movel %d0,%a2@(48)                                	<== 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;
   52ee4:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   52ee8:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );
   52eec:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   52eee:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   52ef2:	2540 001c      	movel %d0,%a2@(28)                                	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   52ef6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52ef8:	4879 0007 16dc 	pea 716dc <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   52efe:	4eb9 0005 7810 	jsr 57810 <_Watchdog_Insert>                      	<== NOT EXECUTED


      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
      _Thread_Enable_dispatch();
   52f04:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f0a:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   52f0e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );


      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
      _Thread_Enable_dispatch();
   52f12:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f14:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );


      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
      _Thread_Enable_dispatch();
   52f16:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f18:	4e75           	rts                                               	<== NOT EXECUTED
   52f1a:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   52f1e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52f22:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !routine )
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52f24:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f26:	4e75           	rts                                               	<== NOT EXECUTED
   52f28:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   52f2c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52f30:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control      *the_timer;
  Objects_Locations   location;
  ISR_Level           level;

  if ( ticks == 0 )
   52f32:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f34:	4e75           	rts                                               	<== NOT EXECUTED
   52f36:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   52f3a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52f3e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  ISR_Level           level;

  if ( ticks == 0 )
    return RTEMS_INVALID_NUMBER;

  if ( !routine )
   52f40:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f42:	4e75           	rts                                               	<== NOT EXECUTED
         *  Check to see if the watchdog has just been inserted by a
         *  higher priority interrupt.  If so, abandon this insert.
         */

        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
          _ISR_Enable( level );
   52f44:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   52f46:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f4c:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   52f50:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   52f54:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
         *  higher priority interrupt.  If so, abandon this insert.
         */

        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
          _ISR_Enable( level );
          _Thread_Enable_dispatch();
   52f56:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f58:	4e75           	rts                                               	<== NOT EXECUTED
	...

00052f5c <rtems_timer_fire_when>:
  Objects_Id                          id,
  rtems_time_of_day                  *wall_time,
  rtems_timer_service_routine_entry   routine,
  void                               *user_data
)
{
   52f5c:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   52f60:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
  Timer_Control       *the_timer;
  Objects_Locations    location;
  rtems_interval       seconds;

  if ( !_TOD_Is_set )
   52f64:	4a39 0007 1614 	tstb 71614 <_TOD_Is_set>                          	<== NOT EXECUTED
   52f6a:	660c           	bnes 52f78 <rtems_timer_fire_when+0x1c>           	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f6c:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   52f72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control       *the_timer;
  Objects_Locations    location;
  rtems_interval       seconds;

  if ( !_TOD_Is_set )
   52f74:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52f76:	4e75           	rts                                               	<== NOT EXECUTED
  rtems_interval       seconds;

  if ( !_TOD_Is_set )
    return RTEMS_NOT_DEFINED;

  if ( !_TOD_Validate( wall_time ) )
   52f78:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52f7c:	4eb9 0005 010c 	jsr 5010c <_TOD_Validate>                         	<== NOT EXECUTED
   52f82:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   52f84:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   52f86:	671e           	beqs 52fa6 <rtems_timer_fire_when+0x4a>           	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  if ( !routine )
   52f88:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   52f8c:	6700 00b2      	beqw 53040 <rtems_timer_fire_when+0xe4>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  seconds = _TOD_To_seconds( wall_time );
   52f90:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   52f94:	4eb9 0004 ffd8 	jsr 4ffd8 <_TOD_To_seconds>                       	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   52f9a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  if ( !routine )
    return RTEMS_INVALID_ADDRESS;

  seconds = _TOD_To_seconds( wall_time );
   52f9c:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   52f9e:	b0b9 0007 1692 	cmpl 71692 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   52fa4:	620c           	bhis 52fb2 <rtems_timer_fire_when+0x56>           	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52fa6:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   52fac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
      _Watchdog_Insert_seconds(
         &the_timer->Ticker,
         seconds - _TOD_Seconds_since_epoch
       );
      _Thread_Enable_dispatch();
      return RTEMS_SUCCESSFUL;
   52fae:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   52fb0:	4e75           	rts                                               	<== NOT EXECUTED
   52fb2:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   52fb6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   52fba:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   52fc0:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  seconds = _TOD_To_seconds( wall_time );
  if ( seconds <= _TOD_Seconds_since_epoch )
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   52fc6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   52fcc:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   52fce:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   52fd2:	6660           	bnes 53034 <rtems_timer_fire_when+0xd8>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   52fd4:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   52fd6:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   52fdc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   52fde:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   52fe4:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   52fe8:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
      the_timer->the_class = TIMER_TIME_OF_DAY;
   52fec:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   52fee:	96b9 0007 1692 	subl 71692 <_TOD_Now>,%d3                         	<== NOT EXECUTED
   52ff4:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   52ff8:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   52ffc:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   53002:	2540 002c      	movel %d0,%a2@(44)                                	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   53006:	2543 001c      	movel %d3,%a2@(28)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   5300a:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   5300e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   53010:	4879 0007 16d0 	pea 716d0 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   53016:	4eb9 0005 7810 	jsr 57810 <_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();
   5301c:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   53022:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53028:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   5302e:	4e5e           	unlk %fp                                          	<== 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();
   53030:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53032:	4e75           	rts                                               	<== NOT EXECUTED
   53034:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   5303a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  seconds = _TOD_To_seconds( wall_time );
  if ( seconds <= _TOD_Seconds_since_epoch )
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   5303c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5303e:	4e75           	rts                                               	<== NOT EXECUTED
   53040:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   53046:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !_TOD_Validate( wall_time ) )
    return RTEMS_INVALID_CLOCK;

  if ( !routine )
   53048:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5304a:	4e75           	rts

0005304c <rtems_timer_get_information>:

rtems_status_code rtems_timer_get_information(
  Objects_Id               id,
  rtems_timer_information *the_info
)
{
   5304c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   53050:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   53052:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  if ( !the_info )
   53056:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   53058:	6752           	beqs 530ac <rtems_timer_get_information+0x60>     	<== NOT EXECUTED
   5305a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5305e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   53062:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   53068:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   5306e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   53074:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   53076:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5307a:	6626           	bnes 530a2 <rtems_timer_get_information+0x56>     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_info->the_class  = the_timer->the_class;
   5307c:	24a8 0038      	movel %a0@(56),%a2@                               	<== NOT EXECUTED
      the_info->initial    = the_timer->Ticker.initial;
   53080:	2568 001c 0004 	movel %a0@(28),%a2@(4)                            	<== NOT EXECUTED
      the_info->start_time = the_timer->Ticker.start_time;
   53086:	2568 0024 0008 	movel %a0@(36),%a2@(8)                            	<== NOT EXECUTED
      the_info->stop_time  = the_timer->Ticker.stop_time;
   5308c:	2568 0028 000c 	movel %a0@(40),%a2@(12)                           	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   53092:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53098:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5309c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      the_info->the_class  = the_timer->the_class;
      the_info->initial    = the_timer->Ticker.initial;
      the_info->start_time = the_timer->Ticker.start_time;
      the_info->stop_time  = the_timer->Ticker.stop_time;
      _Thread_Enable_dispatch();
   5309e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   530a0:	4e75           	rts                                               	<== NOT EXECUTED
   530a2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   530a6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( !the_info )
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   530a8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   530aa:	4e75           	rts                                               	<== NOT EXECUTED
   530ac:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   530b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
)
{
  Timer_Control     *the_timer;
  Objects_Locations  location;

  if ( !the_info )
   530b2:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   530b4:	4e75           	rts                                               	<== NOT EXECUTED
	...

000530b8 <rtems_timer_ident>:

rtems_status_code rtems_timer_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   530b8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   530bc:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   530c0:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   530c6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   530ca:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   530d0:	4eb9 0005 5bb8 	jsr 55bb8 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   530d6:	41f9 0006 a75e 	lea 6a75e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   530dc:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   530e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   530e2:	4e75           	rts

000533a0 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
  uint32_t             priority,
  uint32_t             stack_size,
  rtems_attribute      attribute_set
)
{
   533a0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   533a4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   533a6:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   533aa:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   533ac:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   533ae:	660e           	bnes 533be <rtems_timer_initiate_server+0x1e>     	<== 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;
   533b0:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
  }

  return status;
}
   533b2:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   533b6:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   533ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   533bc:	4e75           	rts                                               	<== NOT EXECUTED
   533be:	4280           	clrl %d0                                          	<== NOT EXECUTED
   533c0:	1039 0006 b7b2 	moveb 6b7b2 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   533c6:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   533c8:	643c           	bccs 53406 <rtems_timer_initiate_server+0x66>     	<== NOT EXECUTED
   *  structured so we check it is invalid before looking for
   *  a specific invalid value as the default.
   */
  _priority = priority;
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
   533ca:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
   533cc:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   533ce:	66e0           	bnes 533b0 <rtems_timer_initiate_server+0x10>     	<== NOT EXECUTED
   533d0:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   533d6:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   533d8:	4283           	clrl %d3                                          	<== NOT EXECUTED
   533da:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

  /*
   *  Just to make sure this is only called once.
   */
  _Thread_Disable_dispatch();
    tmpInitialized  = initialized;
   533e0:	1439 0006 ca80 	moveb 6ca80 <initialized.4039>,%d2                	<== NOT EXECUTED
    initialized = true;
   533e6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   533e8:	13c0 0006 ca80 	moveb %d0,6ca80 <initialized.4039>                	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   533ee:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

  if ( tmpInitialized )
   533f4:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   533f6:	6736           	beqs 5342e <rtems_timer_initiate_server+0x8e>     	<== NOT EXECUTED
     */
    initialized = false;
  }

  return status;
}
   533f8:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   533fc:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   53400:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  _Thread_Disable_dispatch();
    tmpInitialized  = initialized;
    initialized = true;
  _Thread_Enable_dispatch();

  if ( tmpInitialized )
   53402:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
     */
    initialized = false;
  }

  return status;
}
   53404:	4e75           	rts                                               	<== NOT EXECUTED
   53406:	2039 0007 1600 	movel 71600 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   5340c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   5340e:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
   53410:	23c0 0007 1600 	movel %d0,71600 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

  /*
   *  Just to make sure this is only called once.
   */
  _Thread_Disable_dispatch();
    tmpInitialized  = initialized;
   53416:	1439 0006 ca80 	moveb 6ca80 <initialized.4039>,%d2                	<== NOT EXECUTED
    initialized = true;
   5341c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   5341e:	13c0 0006 ca80 	moveb %d0,6ca80 <initialized.4039>                	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   53424:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

  if ( tmpInitialized )
   5342a:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   5342c:	66ca           	bnes 533f8 <rtems_timer_initiate_server+0x58>     	<== 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(
   5342e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   53432:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   53436:	08c1 000f      	bset #15,%d1                                      	<== NOT EXECUTED
   5343a:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5343c:	203c 0007 157c 	movel #464252,%d0                                 	<== NOT EXECUTED
   53442:	4878 0100      	pea 100 <FP_REGS_SAVED+0xc0>                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   53446:	223c 0007 1578 	movel #464248,%d1                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5344c:	23c0 0007 1578 	movel %d0,71578 <_Timer_To_be_inserted>           	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   53452:	23c1 0007 1580 	movel %d1,71580 <_Timer_To_be_inserted+0x8>       	<== NOT EXECUTED
   53458:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   5345c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   5345e:	42b9 0007 157c 	clrl 7157c <_Timer_To_be_inserted+0x4>            	<== NOT EXECUTED
   53464:	2f3c 5449 4d45 	movel #1414090053,%sp@-                           	<== NOT EXECUTED
   5346a:	4eb9 0005 25cc 	jsr 525cc <rtems_task_create>                     	<== 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) {
   53470:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   53476:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   53478:	6600 00b8      	bnew 53532 <rtems_timer_initiate_server+0x192>    	<== 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(
   5347c:	226e fffc      	moveal %fp@(-4),%a1                               	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object(
  Objects_Information *information,
  uint16_t             index
)
{
  if ( index > information->maximum )
   53480:	4280           	clrl %d0                                          	<== NOT EXECUTED
   53482:	4281           	clrl %d1                                          	<== NOT EXECUTED
   53484:	3039 0007 152a 	movew 7152a <_RTEMS_tasks_Information+0xe>,%d0    	<== NOT EXECUTED
   5348a:	3209           	movew %a1,%d1                                     	<== NOT EXECUTED
   5348c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   5348e:	6400 00b6      	bccw 53546 <rtems_timer_initiate_server+0x1a6>    	<== NOT EXECUTED
   53492:	91c8           	subal %a0,%a0                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   53494:	203c 0005 610c 	movel #352524,%d0                                 	<== NOT EXECUTED
   5349a:	2140 0064      	movel %d0,%a0@(100)                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5349e:	223c 0007 155c 	movel #464220,%d1                                 	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   534a4:	203c 0007 1558 	movel #464216,%d0                                 	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   534aa:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   534ae:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   534b2:	23c1 0007 1558 	movel %d1,71558 <_Timer_Ticks_chain>              	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   534b8:	223c 0007 1570 	movel #464240,%d1                                 	<== NOT EXECUTED
   534be:	2149 0068      	movel %a1,%a0@(104)                               	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   534c2:	23c0 0007 1560 	movel %d0,71560 <_Timer_Ticks_chain+0x8>          	<== NOT EXECUTED
   534c8:	203c 0007 156c 	movel #464236,%d0                                 	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   534ce:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   534d0:	23c1 0007 156c 	movel %d1,7156c <_Timer_Seconds_chain>            	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   534d6:	223c 0005 610c 	movel #352524,%d1                                 	<== NOT EXECUTED
   534dc:	4879 0005 36ae 	pea 536ae <_Timer_Server_body>                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   534e2:	23c0 0007 1574 	movel %d0,71574 <_Timer_Seconds_chain+0x8>        	<== 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;
   534e8:	203c 0005 35f2 	movel #341490,%d0                                 	<== NOT EXECUTED
   534ee:	23c1 0007 15a0 	movel %d1,715a0 <_Timer_Seconds_timer+0x1c>       	<== NOT EXECUTED

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   534f4:	2f09           	movel %a1,%sp@-                                   	<== 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;
   534f6:	23c0 0007 18be 	movel %d0,718be <_Timer_Server_schedule_operation>	<== 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(
   534fc:	23c8 0007 18c2 	movel %a0,718c2 <_Timer_Server>                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   53502:	42b9 0007 155c 	clrl 7155c <_Timer_Ticks_chain+0x4>               	<== NOT EXECUTED
   53508:	42b9 0007 1570 	clrl 71570 <_Timer_Seconds_chain+0x4>             	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   5350e:	42b9 0007 158c 	clrl 7158c <_Timer_Seconds_timer+0x8>             	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   53514:	23c9 0007 15a4 	movel %a1,715a4 <_Timer_Seconds_timer+0x20>       	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   5351a:	42b9 0007 15a8 	clrl 715a8 <_Timer_Seconds_timer+0x24>            	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   53520:	4eb9 0005 2b10 	jsr 52b10 <rtems_task_start>                      	<== 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) {
   53526:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5352c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5352e:	6700 fe82      	beqw 533b2 <rtems_timer_initiate_server+0x12>     	<== NOT EXECUTED
     */
    initialized = false;
  }

  return status;
}
   53532:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53536:	262e fff8      	movel %fp@(-8),%d3                                	<== 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;
   5353a:	4201           	clrb %d1                                          	<== NOT EXECUTED
  }

  return status;
}
   5353c:	4e5e           	unlk %fp                                          	<== 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;
   5353e:	13c1 0006 ca80 	moveb %d1,6ca80 <initialized.4039>                	<== NOT EXECUTED
  }

  return status;
}
   53544:	4e75           	rts                                               	<== NOT EXECUTED
   53546:	2079 0007 1536 	moveal 71536 <_RTEMS_tasks_Information+0x1a>,%a0  	<== NOT EXECUTED
   5354c:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   53550:	203c 0005 610c 	movel #352524,%d0                                 	<== NOT EXECUTED
   53556:	2140 0064      	movel %d0,%a0@(100)                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5355a:	223c 0007 155c 	movel #464220,%d1                                 	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   53560:	203c 0007 1558 	movel #464216,%d0                                 	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   53566:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   5356a:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5356e:	23c1 0007 1558 	movel %d1,71558 <_Timer_Ticks_chain>              	<== NOT EXECUTED
   53574:	223c 0007 1570 	movel #464240,%d1                                 	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   5357a:	2149 0068      	movel %a1,%a0@(104)                               	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   5357e:	23c0 0007 1560 	movel %d0,71560 <_Timer_Ticks_chain+0x8>          	<== NOT EXECUTED
   53584:	203c 0007 156c 	movel #464236,%d0                                 	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   5358a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   5358c:	23c1 0007 156c 	movel %d1,7156c <_Timer_Seconds_chain>            	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   53592:	223c 0005 610c 	movel #352524,%d1                                 	<== NOT EXECUTED
   53598:	4879 0005 36ae 	pea 536ae <_Timer_Server_body>                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   5359e:	23c0 0007 1574 	movel %d0,71574 <_Timer_Seconds_chain+0x8>        	<== 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;
   535a4:	203c 0005 35f2 	movel #341490,%d0                                 	<== NOT EXECUTED
   535aa:	23c1 0007 15a0 	movel %d1,715a0 <_Timer_Seconds_timer+0x1c>       	<== NOT EXECUTED

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   535b0:	2f09           	movel %a1,%sp@-                                   	<== 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;
   535b2:	23c0 0007 18be 	movel %d0,718be <_Timer_Server_schedule_operation>	<== 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(
   535b8:	23c8 0007 18c2 	movel %a0,718c2 <_Timer_Server>                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   535be:	42b9 0007 155c 	clrl 7155c <_Timer_Ticks_chain+0x4>               	<== NOT EXECUTED
   535c4:	42b9 0007 1570 	clrl 71570 <_Timer_Seconds_chain+0x4>             	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   535ca:	42b9 0007 158c 	clrl 7158c <_Timer_Seconds_timer+0x8>             	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   535d0:	23c9 0007 15a4 	movel %a1,715a4 <_Timer_Seconds_timer+0x20>       	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   535d6:	42b9 0007 15a8 	clrl 715a8 <_Timer_Seconds_timer+0x24>            	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   535dc:	4eb9 0005 2b10 	jsr 52b10 <rtems_task_start>                      	<== 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) {
   535e2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   535e8:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   535ea:	6600 ff46      	bnew 53532 <rtems_timer_initiate_server+0x192>    	<== NOT EXECUTED
   535ee:	6000 fdc2      	braw 533b2 <rtems_timer_initiate_server+0x12>     	<== NOT EXECUTED

000530e4 <rtems_timer_reset>:
 */

rtems_status_code rtems_timer_reset(
  Objects_Id id
)
{
   530e4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   530e8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   530ea:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   530ec:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   530f0:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   530f4:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   530fa:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   53100:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   53106:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   53108:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5310c:	670e           	beqs 5311c <rtems_timer_reset+0x38>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5310e:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53112:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   53116:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   53118:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5311a:	4e75           	rts                                               	<== NOT EXECUTED

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      switch ( the_timer->the_class ) {
   5311c:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   53120:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   53122:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   53124:	6756           	beqs 5317c <rtems_timer_reset+0x98>               	<== NOT EXECUTED
   53126:	621c           	bhis 53144 <rtems_timer_reset+0x60>               	<== NOT EXECUTED
   53128:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   5312c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   5312e:	6538           	bcss 53168 <rtems_timer_reset+0x84>               	<== NOT EXECUTED
          (*_Timer_Server_schedule_operation)( the_timer );
          break;
        case TIMER_TIME_OF_DAY:
        case TIMER_TIME_OF_DAY_ON_TASK:
        case TIMER_DORMANT:
          _Thread_Enable_dispatch();
   53130:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53136:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   5313a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5313e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          (*_Timer_Server_schedule_operation)( the_timer );
          break;
        case TIMER_TIME_OF_DAY:
        case TIMER_TIME_OF_DAY_ON_TASK:
        case TIMER_DORMANT:
          _Thread_Enable_dispatch();
   53140:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53142:	4e75           	rts                                               	<== NOT EXECUTED
  switch ( location ) {

    case OBJECTS_LOCAL:
      switch ( the_timer->the_class ) {
        case TIMER_INTERVAL:
          _Watchdog_Remove( &the_timer->Ticker );
   53144:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   53146:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   5314c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5314e:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
   53154:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   53156:	4879 0007 16dc 	pea 716dc <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   5315c:	4eb9 0005 7810 	jsr 57810 <_Watchdog_Insert>                      	<== NOT EXECUTED
   53162:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
        case TIMER_TIME_OF_DAY_ON_TASK:
        case TIMER_DORMANT:
          _Thread_Enable_dispatch();
          return RTEMS_NOT_DEFINED;
      }
      _Thread_Enable_dispatch();
   53168:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5316e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53170:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53174:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   53178:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5317a:	4e75           	rts                                               	<== NOT EXECUTED
        case TIMER_INTERVAL:
          _Watchdog_Remove( &the_timer->Ticker );
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
          break;
        case TIMER_INTERVAL_ON_TASK:
          if ( !_Timer_Server_schedule_operation ) {
   5317c:	4ab9 0007 18be 	tstl 718be <_Timer_Server_schedule_operation>     	<== NOT EXECUTED
   53182:	6720           	beqs 531a4 <rtems_timer_reset+0xc0>               	<== NOT EXECUTED
            _Thread_Enable_dispatch();
            return RTEMS_INCORRECT_STATE;
          }
          _Watchdog_Remove( &the_timer->Ticker );
   53184:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   53188:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
          (*_Timer_Server_schedule_operation)( the_timer );
   5318e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   53190:	2079 0007 18be 	moveal 718be <_Timer_Server_schedule_operation>,%a0	<== NOT EXECUTED
   53196:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   53198:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
        case TIMER_TIME_OF_DAY_ON_TASK:
        case TIMER_DORMANT:
          _Thread_Enable_dispatch();
          return RTEMS_NOT_DEFINED;
      }
      _Thread_Enable_dispatch();
   5319a:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   531a0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   531a2:	60cc           	bras 53170 <rtems_timer_reset+0x8c>               	<== NOT EXECUTED
          _Watchdog_Remove( &the_timer->Ticker );
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
          break;
        case TIMER_INTERVAL_ON_TASK:
          if ( !_Timer_Server_schedule_operation ) {
            _Thread_Enable_dispatch();
   531a4:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   531aa:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   531ae:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   531b2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
          _Watchdog_Remove( &the_timer->Ticker );
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
          break;
        case TIMER_INTERVAL_ON_TASK:
          if ( !_Timer_Server_schedule_operation ) {
            _Thread_Enable_dispatch();
   531b4:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   531b6:	4e75           	rts

000531b8 <rtems_timer_server_fire_after>:
  Objects_Id                         id,
  rtems_interval                     ticks,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   531b8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   531bc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Timer_Control        *the_timer;
  Objects_Locations     location;
  ISR_Level             level;

  if ( !_Timer_Server )
   531be:	4ab9 0007 18c2 	tstl 718c2 <_Timer_Server>                        	<== NOT EXECUTED
   531c4:	6700 00bc      	beqw 53282 <rtems_timer_server_fire_after+0xca>   	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !routine )
   531c8:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   531cc:	6700 00be      	beqw 5328c <rtems_timer_server_fire_after+0xd4>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( ticks == 0 )
   531d0:	4aae 000c      	tstl %fp@(12)                                     	<== NOT EXECUTED
   531d4:	660a           	bnes 531e0 <rtems_timer_server_fire_after+0x28>   	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   531d6:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   531da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !routine )
    return RTEMS_INVALID_ADDRESS;

  if ( ticks == 0 )
   531dc:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   531de:	4e75           	rts                                               	<== NOT EXECUTED
   531e0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   531e4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   531e8:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   531ee:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED

  if ( ticks == 0 )
    return RTEMS_INVALID_NUMBER;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   531f4:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   531fa:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   531fc:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   53200:	6664           	bnes 53266 <rtems_timer_server_fire_after+0xae>   	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   53202:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   53206:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED

      _ISR_Disable( level );
   5320c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   53212:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   53214:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   53216:	46c0           	movew %d0,%sr                                     	<== 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 ) {
   53218:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   5321a:	4aaa 0018      	tstl %a2@(24)                                     	<== NOT EXECUTED
   5321e:	6650           	bnes 53270 <rtems_timer_server_fire_after+0xb8>   	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   53220:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   53224:	2540 002c      	movel %d0,%a2@(44)                                	<== 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;
   53228:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   5322a:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
   53230:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   53234:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   53238:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
        the_timer->Ticker.initial = ticks;
   5323c:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   53240:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
   53244:	2540 001c      	movel %d0,%a2@(28)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   53248:	46c1           	movew %d1,%sr                                     	<== 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 );
   5324a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5324c:	2079 0007 18be 	moveal 718be <_Timer_Server_schedule_operation>,%a0	<== NOT EXECUTED
   53252:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   53254:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5325a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */

      (*_Timer_Server_schedule_operation)( the_timer );

      _Thread_Enable_dispatch();
   5325e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53260:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */

      (*_Timer_Server_schedule_operation)( the_timer );

      _Thread_Enable_dispatch();
   53262:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53264:	4e75           	rts                                               	<== NOT EXECUTED
   53266:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5326a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  if ( ticks == 0 )
    return RTEMS_INVALID_NUMBER;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   5326c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5326e:	4e75           	rts                                               	<== NOT EXECUTED
         *  Check to see if the watchdog has just been inserted by a
         *  higher priority interrupt.  If so, abandon this insert.
         */

        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
          _ISR_Enable( level );
   53270:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   53272:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53278:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5327c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
         *  higher priority interrupt.  If so, abandon this insert.
         */

        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
          _ISR_Enable( level );
          _Thread_Enable_dispatch();
   5327e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53280:	4e75           	rts                                               	<== NOT EXECUTED
   53282:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   53286:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control        *the_timer;
  Objects_Locations     location;
  ISR_Level             level;

  if ( !_Timer_Server )
   53288:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5328a:	4e75           	rts                                               	<== NOT EXECUTED
   5328c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   53290:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  ISR_Level             level;

  if ( !_Timer_Server )
    return RTEMS_INCORRECT_STATE;

  if ( !routine )
   53292:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53294:	4e75           	rts                                               	<== NOT EXECUTED
	...

00053298 <rtems_timer_server_fire_when>:
  Objects_Id                         id,
  rtems_time_of_day                  *wall_time,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   53298:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5329c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5329e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Timer_Control        *the_timer;
  Objects_Locations     location;
  rtems_interval        seconds;

  if ( !_Timer_Server )
   532a0:	4ab9 0007 18c2 	tstl 718c2 <_Timer_Server>                        	<== NOT EXECUTED
   532a6:	6700 00da      	beqw 53382 <rtems_timer_server_fire_when+0xea>    	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !_TOD_Is_set )
   532aa:	4a39 0007 1614 	tstb 71614 <_TOD_Is_set>                          	<== NOT EXECUTED
   532b0:	6700 00b4      	beqw 53366 <rtems_timer_server_fire_when+0xce>    	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !routine )
   532b4:	4aae 0010      	tstl %fp@(16)                                     	<== NOT EXECUTED
   532b8:	6700 00ba      	beqw 53374 <rtems_timer_server_fire_when+0xdc>    	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
   532bc:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   532c0:	4eb9 0005 010c 	jsr 5010c <_TOD_Validate>                         	<== NOT EXECUTED
   532c6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   532c8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   532ca:	660e           	bnes 532da <rtems_timer_server_fire_when+0x42>    	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   532cc:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   532d0:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   532d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
       */

      (*_Timer_Server_schedule_operation)( the_timer );

      _Thread_Enable_dispatch();
      return RTEMS_SUCCESSFUL;
   532d6:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   532d8:	4e75           	rts                                               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( wall_time );
   532da:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   532de:	4eb9 0004 ffd8 	jsr 4ffd8 <_TOD_To_seconds>                       	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   532e4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( wall_time );
   532e6:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   532e8:	b0b9 0007 1692 	cmpl 71692 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   532ee:	63dc           	blss 532cc <rtems_timer_server_fire_when+0x34>    	<== NOT EXECUTED
   532f0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   532f4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   532f8:	4879 0007 1882 	pea 71882 <_Timer_Information>                    	<== NOT EXECUTED
   532fe:	4eb9 0005 5a20 	jsr 55a20 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   53304:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5330a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   5330c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   53310:	667e           	bnes 53390 <rtems_timer_server_fire_when+0xf8>    	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   53312:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   53316:	4eb9 0005 7958 	jsr 57958 <_Watchdog_Remove>                      	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   5331c:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   53320:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   53324:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
   53328:	94b9 0007 1692 	subl 71692 <_TOD_Now>,%d2                         	<== NOT EXECUTED
   5332e:	2540 002c      	movel %d0,%a2@(44)                                	<== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
   53332:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   53334:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
   5333a:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
   5333e:	2542 001c      	movel %d2,%a2@(28)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   53342:	42aa 0018      	clrl %a2@(24)                                     	<== 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 );
   53346:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   53348:	2079 0007 18be 	moveal 718be <_Timer_Server_schedule_operation>,%a0	<== NOT EXECUTED
   5334e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   53350:	4eb9 0005 62a4 	jsr 562a4 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53356:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   5335a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */

      (*_Timer_Server_schedule_operation)( the_timer );

      _Thread_Enable_dispatch();
   5335e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53360:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */

      (*_Timer_Server_schedule_operation)( the_timer );

      _Thread_Enable_dispatch();
   53362:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53364:	4e75           	rts                                               	<== NOT EXECUTED
   53366:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   5336a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5336e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  rtems_interval        seconds;

  if ( !_Timer_Server )
    return RTEMS_INCORRECT_STATE;

  if ( !_TOD_Is_set )
   53370:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53372:	4e75           	rts                                               	<== NOT EXECUTED
   53374:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53378:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5337c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !_TOD_Is_set )
    return RTEMS_NOT_DEFINED;

  if ( !routine )
   5337e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   53380:	4e75           	rts                                               	<== NOT EXECUTED
   53382:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53386:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5338a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  Timer_Control        *the_timer;
  Objects_Locations     location;
  rtems_interval        seconds;

  if ( !_Timer_Server )
   5338c:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5338e:	4e75           	rts                                               	<== NOT EXECUTED
   53390:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   53394:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   53398:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  seconds = _TOD_To_seconds( wall_time );
  if ( seconds <= _TOD_Seconds_since_epoch )
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   5339a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5339c:	4e75           	rts                                               	<== NOT EXECUTED
	...